wpa_supplicant/wpa_supplicant.c

   1 /*
   2  * WPA Supplicant
   3  * Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  *
  14  * This file implements functions for registering and unregistering
  15  * %wpa_supplicant interfaces. In addition, this file contains number of
  16  * functions for managing network connections.
  17  */
  18
  19 #include "includes.h"
  20
  21 #include "common.h"
  22 #include "crypto/random.h"
  23 #include "eapol_supp/eapol_supp_sm.h"
  24 #include "eap_peer/eap.h"
  25 #include "eap_server/eap_methods.h"
  26 #include "rsn_supp/wpa.h"
  27 #include "eloop.h"
  28 #include "config.h"
  29 #include "l2_packet/l2_packet.h"
  30 #include "wpa_supplicant_i.h"
  31 #include "driver_i.h"
  32 #include "ctrl_iface.h"
  33 #include "pcsc_funcs.h"
  34 #include "common/version.h"
  35 #include "rsn_supp/preauth.h"
  36 #include "rsn_supp/pmksa_cache.h"
  37 #include "common/wpa_ctrl.h"
  38 #include "mlme.h"
  39 #include "common/ieee802_11_defs.h"
  40 #include "p2p/p2p.h"
  41 #include "blacklist.h"
  42 #include "wpas_glue.h"
  43 #include "wps_supplicant.h"
  44 #include "ibss_rsn.h"
  45 #include "sme.h"
  46 #include "ap.h"
  47 #include "p2p_supplicant.h"
  48 #include "notify.h"
  49 #include "bgscan.h"
  50 #include "bss.h"
  51 #include "scan.h"
  52
  53 const char *wpa_supplicant_version =
  54 "wpa_supplicant v" VERSION_STR "\n"
  55 "Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi> and contributors";
  56
  57 const char *wpa_supplicant_license =
  58 "This program is free software. You can distribute it and/or modify it\n"
  59 "under the terms of the GNU General Public License version 2.\n"
  60 "\n"
  61 "Alternatively, this software may be distributed under the terms of the\n"
  62 "BSD license. See README and COPYING for more details.\n"
  63 #ifdef EAP_TLS_OPENSSL
  64 "\nThis product includes software developed by the OpenSSL Project\n"
  65 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
  66 #endif /* EAP_TLS_OPENSSL */
  67 ;
  68
  69 #ifndef CONFIG_NO_STDOUT_DEBUG
  70 /* Long text divided into parts in order to fit in C89 strings size limits. */
  71 const char *wpa_supplicant_full_license1 =
  72 "This program is free software; you can redistribute it and/or modify\n"
  73 "it under the terms of the GNU General Public License version 2 as\n"
  74 "published by the Free Software Foundation.\n"
  75 "\n"
  76 "This program is distributed in the hope that it will be useful,\n"
  77 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
  78 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
  79 "GNU General Public License for more details.\n"
  80 "\n";
  81 const char *wpa_supplicant_full_license2 =
  82 "You should have received a copy of the GNU General Public License\n"
  83 "along with this program; if not, write to the Free Software\n"
  84 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n"
  85 "\n"
  86 "Alternatively, this software may be distributed under the terms of the\n"
  87 "BSD license.\n"
  88 "\n"
  89 "Redistribution and use in source and binary forms, with or without\n"
  90 "modification, are permitted provided that the following conditions are\n"
  91 "met:\n"
  92 "\n";
  93 const char *wpa_supplicant_full_license3 =
  94 "1. Redistributions of source code must retain the above copyright\n"
  95 "   notice, this list of conditions and the following disclaimer.\n"
  96 "\n"
  97 "2. Redistributions in binary form must reproduce the above copyright\n"
  98 "   notice, this list of conditions and the following disclaimer in the\n"
  99 "   documentation and/or other materials provided with the distribution.\n"
 100 "\n";
 101 const char *wpa_supplicant_full_license4 =
 102 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
 103 "   names of its contributors may be used to endorse or promote products\n"
 104 "   derived from this software without specific prior written permission.\n"
 105 "\n"
 106 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
 107 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
 108 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
 109 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
 110 const char *wpa_supplicant_full_license5 =
 111 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
 112 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
 113 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
 114 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
 115 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
 116 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
 117 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
 118 "\n";
 119 #endif /* CONFIG_NO_STDOUT_DEBUG */
 120
 121 extern int wpa_debug_level;
 122 extern int wpa_debug_show_keys;
 123 extern int wpa_debug_timestamp;
 124 extern struct wpa_driver_ops *wpa_drivers[];
 125
 126 /* Configure default/group WEP keys for static WEP */
 127 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
 128 {
 129         int i, set = 0;
 130
 131         for (i = 0; i < NUM_WEP_KEYS; i++) {
 132                 if (ssid->wep_key_len[i] == 0)
 133                         continue;
 134
 135                 set = 1;
 136                 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
 137                                 i, i == ssid->wep_tx_keyidx, NULL, 0,
 138                                 ssid->wep_key[i], ssid->wep_key_len[i]);
 139         }
 140
 141         return set;
 142 }
 143
 144
 145 static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
 146                                            struct wpa_ssid *ssid)
 147 {
 148         u8 key[32];
 149         size_t keylen;
 150         enum wpa_alg alg;
 151         u8 seq[6] = { 0 };
 152
 153         /* IBSS/WPA-None uses only one key (Group) for both receiving and
 154          * sending unicast and multicast packets. */
 155
 156         if (ssid->mode != WPAS_MODE_IBSS) {
 157                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
 158                         "IBSS/ad-hoc) for WPA-None", ssid->mode);
 159                 return -1;
 160         }
 161
 162         if (!ssid->psk_set) {
 163                 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
 164                         "WPA-None");
 165                 return -1;
 166         }
 167
 168         switch (wpa_s->group_cipher) {
 169         case WPA_CIPHER_CCMP:
 170                 os_memcpy(key, ssid->psk, 16);
 171                 keylen = 16;
 172                 alg = WPA_ALG_CCMP;
 173                 break;
 174         case WPA_CIPHER_TKIP:
 175                 /* WPA-None uses the same Michael MIC key for both TX and RX */
 176                 os_memcpy(key, ssid->psk, 16 + 8);
 177                 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
 178                 keylen = 32;
 179                 alg = WPA_ALG_TKIP;
 180                 break;
 181         default:
 182                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
 183                         "WPA-None", wpa_s->group_cipher);
 184                 return -1;
 185         }
 186
 187         /* TODO: should actually remember the previously used seq#, both for TX
 188          * and RX from each STA.. */
 189
 190         return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
 191 }
 192
 193
 194 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
 195 {
 196         struct wpa_supplicant *wpa_s = eloop_ctx;
 197         const u8 *bssid = wpa_s->bssid;
 198         if (is_zero_ether_addr(bssid))
 199                 bssid = wpa_s->pending_bssid;
 200         wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
 201                 MAC2STR(bssid));
 202         wpa_blacklist_add(wpa_s, bssid);
 203         wpa_sm_notify_disassoc(wpa_s->wpa);
 204         wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 205         wpa_s->reassociate = 1;
 206
 207         /*
 208          * If we timed out, the AP or the local radio may be busy.
 209          * So, wait a second until scanning again.
 210          */
 211         wpa_supplicant_req_scan(wpa_s, 1, 0);
 212 }
 213
 214
 215 /**
 216  * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
 217  * @wpa_s: Pointer to wpa_supplicant data
 218  * @sec: Number of seconds after which to time out authentication
 219  * @usec: Number of microseconds after which to time out authentication
 220  *
 221  * This function is used to schedule a timeout for the current authentication
 222  * attempt.
 223  */
 224 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
 225                                      int sec, int usec)
 226 {
 227         if (wpa_s->conf && wpa_s->conf->ap_scan == 0 &&
 228             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 229                 return;
 230
 231         wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
 232                 "%d usec", sec, usec);
 233         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 234         eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
 235 }
 236
 237
 238 /**
 239  * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
 240  * @wpa_s: Pointer to wpa_supplicant data
 241  *
 242  * This function is used to cancel authentication timeout scheduled with
 243  * wpa_supplicant_req_auth_timeout() and it is called when authentication has
 244  * been completed.
 245  */
 246 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
 247 {
 248         wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
 249         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 250         wpa_blacklist_del(wpa_s, wpa_s->bssid);
 251 }
 252
 253
 254 /**
 255  * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
 256  * @wpa_s: Pointer to wpa_supplicant data
 257  *
 258  * This function is used to configure EAPOL state machine based on the selected
 259  * authentication mode.
 260  */
 261 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
 262 {
 263 #ifdef IEEE8021X_EAPOL
 264         struct eapol_config eapol_conf;
 265         struct wpa_ssid *ssid = wpa_s->current_ssid;
 266
 267 #ifdef CONFIG_IBSS_RSN
 268         if (ssid->mode == WPAS_MODE_IBSS &&
 269             wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
 270             wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
 271                 /*
 272                  * RSN IBSS authentication is per-STA and we can disable the
 273                  * per-BSSID EAPOL authentication.
 274                  */
 275                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 276                 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
 277                 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 278                 return;
 279         }
 280 #endif /* CONFIG_IBSS_RSN */
 281
 282         eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 283         eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 284
 285         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
 286             wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
 287                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 288         else
 289                 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
 290
 291         os_memset(&eapol_conf, 0, sizeof(eapol_conf));
 292         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 293                 eapol_conf.accept_802_1x_keys = 1;
 294                 eapol_conf.required_keys = 0;
 295                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
 296                         eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
 297                 }
 298                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
 299                         eapol_conf.required_keys |=
 300                                 EAPOL_REQUIRE_KEY_BROADCAST;
 301                 }
 302
 303                 if (wpa_s->conf && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 304                         eapol_conf.required_keys = 0;
 305         }
 306         if (wpa_s->conf)
 307                 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
 308         eapol_conf.workaround = ssid->eap_workaround;
 309         eapol_conf.eap_disabled =
 310                 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
 311                 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
 312                 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
 313         eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
 314 #endif /* IEEE8021X_EAPOL */
 315 }
 316
 317
 318 /**
 319  * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
 320  * @wpa_s: Pointer to wpa_supplicant data
 321  * @ssid: Configuration data for the network
 322  *
 323  * This function is used to configure WPA state machine and related parameters
 324  * to a mode where WPA is not enabled. This is called as part of the
 325  * authentication configuration when the selected network does not use WPA.
 326  */
 327 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
 328                                        struct wpa_ssid *ssid)
 329 {
 330         int i;
 331
 332         if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
 333                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
 334         else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
 335                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 336         else
 337                 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
 338         wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
 339         wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
 340         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 341         wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 342         wpa_s->group_cipher = WPA_CIPHER_NONE;
 343         wpa_s->mgmt_group_cipher = 0;
 344
 345         for (i = 0; i < NUM_WEP_KEYS; i++) {
 346                 if (ssid->wep_key_len[i] > 5) {
 347                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
 348                         wpa_s->group_cipher = WPA_CIPHER_WEP104;
 349                         break;
 350                 } else if (ssid->wep_key_len[i] > 0) {
 351                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
 352                         wpa_s->group_cipher = WPA_CIPHER_WEP40;
 353                         break;
 354                 }
 355         }
 356
 357         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
 358         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 359         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 360                          wpa_s->pairwise_cipher);
 361         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 362 #ifdef CONFIG_IEEE80211W
 363         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 364                          wpa_s->mgmt_group_cipher);
 365 #endif /* CONFIG_IEEE80211W */
 366
 367         pmksa_cache_clear_current(wpa_s->wpa);
 368 }
 369
 370
 371 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
 372 {
 373         bgscan_deinit(wpa_s);
 374         scard_deinit(wpa_s->scard);
 375         wpa_s->scard = NULL;
 376         wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
 377         eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
 378         l2_packet_deinit(wpa_s->l2);
 379         wpa_s->l2 = NULL;
 380         if (wpa_s->l2_br) {
 381                 l2_packet_deinit(wpa_s->l2_br);
 382                 wpa_s->l2_br = NULL;
 383         }
 384
 385         if (wpa_s->ctrl_iface) {
 386                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 387                 wpa_s->ctrl_iface = NULL;
 388         }
 389         if (wpa_s->conf != NULL) {
 390                 struct wpa_ssid *ssid;
 391                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
 392                         wpas_notify_network_removed(wpa_s, ssid);
 393                 wpa_config_free(wpa_s->conf);
 394                 wpa_s->conf = NULL;
 395         }
 396
 397         os_free(wpa_s->confname);
 398         wpa_s->confname = NULL;
 399
 400         wpa_sm_set_eapol(wpa_s->wpa, NULL);
 401         eapol_sm_deinit(wpa_s->eapol);
 402         wpa_s->eapol = NULL;
 403
 404         rsn_preauth_deinit(wpa_s->wpa);
 405
 406 #ifdef CONFIG_TDLS
 407         wpa_tdls_deinit(wpa_s->wpa);
 408 #endif /* CONFIG_TDLS */
 409
 410         pmksa_candidate_free(wpa_s->wpa);
 411         wpa_sm_deinit(wpa_s->wpa);
 412         wpa_s->wpa = NULL;
 413         wpa_blacklist_clear(wpa_s);
 414
 415         wpa_bss_deinit(wpa_s);
 416
 417         wpa_supplicant_cancel_scan(wpa_s);
 418         wpa_supplicant_cancel_auth_timeout(wpa_s);
 419
 420         ieee80211_sta_deinit(wpa_s);
 421
 422         wpas_wps_deinit(wpa_s);
 423
 424         wpabuf_free(wpa_s->pending_eapol_rx);
 425         wpa_s->pending_eapol_rx = NULL;
 426
 427 #ifdef CONFIG_IBSS_RSN
 428         ibss_rsn_deinit(wpa_s->ibss_rsn);
 429         wpa_s->ibss_rsn = NULL;
 430 #endif /* CONFIG_IBSS_RSN */
 431
 432         sme_deinit(wpa_s);
 433
 434 #ifdef CONFIG_AP
 435         wpa_supplicant_ap_deinit(wpa_s);
 436 #endif /* CONFIG_AP */
 437
 438 #ifdef CONFIG_P2P
 439         wpas_p2p_deinit(wpa_s);
 440 #endif /* CONFIG_P2P */
 441
 442         os_free(wpa_s->next_scan_freqs);
 443         wpa_s->next_scan_freqs = NULL;
 444 }
 445
 446
 447 /**
 448  * wpa_clear_keys - Clear keys configured for the driver
 449  * @wpa_s: Pointer to wpa_supplicant data
 450  * @addr: Previously used BSSID or %NULL if not available
 451  *
 452  * This function clears the encryption keys that has been previously configured
 453  * for the driver.
 454  */
 455 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
 456 {
 457         if (wpa_s->keys_cleared) {
 458                 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
 459                  * timing issues with keys being cleared just before new keys
 460                  * are set or just after association or something similar. This
 461                  * shows up in group key handshake failing often because of the
 462                  * client not receiving the first encrypted packets correctly.
 463                  * Skipping some of the extra key clearing steps seems to help
 464                  * in completing group key handshake more reliably. */
 465                 wpa_dbg(wpa_s, MSG_DEBUG, "No keys have been configured - "
 466                         "skip key clearing");
 467                 return;
 468         }
 469
 470         /* MLME-DELETEKEYS.request */
 471         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
 472         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
 473         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
 474         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
 475 #ifdef CONFIG_IEEE80211W
 476         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
 477         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
 478 #endif /* CONFIG_IEEE80211W */
 479         if (addr) {
 480                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
 481                                 0);
 482                 /* MLME-SETPROTECTION.request(None) */
 483                 wpa_drv_mlme_setprotection(
 484                         wpa_s, addr,
 485                         MLME_SETPROTECTION_PROTECT_TYPE_NONE,
 486                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 487         }
 488         wpa_s->keys_cleared = 1;
 489 }
 490
 491
 492 /**
 493  * wpa_supplicant_state_txt - Get the connection state name as a text string
 494  * @state: State (wpa_state; WPA_*)
 495  * Returns: The state name as a printable text string
 496  */
 497 const char * wpa_supplicant_state_txt(enum wpa_states state)
 498 {
 499         switch (state) {
 500         case WPA_DISCONNECTED:
 501                 return "DISCONNECTED";
 502         case WPA_INACTIVE:
 503                 return "INACTIVE";
 504         case WPA_INTERFACE_DISABLED:
 505                 return "INTERFACE_DISABLED";
 506         case WPA_SCANNING:
 507                 return "SCANNING";
 508         case WPA_AUTHENTICATING:
 509                 return "AUTHENTICATING";
 510         case WPA_ASSOCIATING:
 511                 return "ASSOCIATING";
 512         case WPA_ASSOCIATED:
 513                 return "ASSOCIATED";
 514         case WPA_4WAY_HANDSHAKE:
 515                 return "4WAY_HANDSHAKE";
 516         case WPA_GROUP_HANDSHAKE:
 517                 return "GROUP_HANDSHAKE";
 518         case WPA_COMPLETED:
 519                 return "COMPLETED";
 520         default:
 521                 return "UNKNOWN";
 522         }
 523 }
 524
 525
 526 #ifdef CONFIG_BGSCAN
 527
 528 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
 529 {
 530         if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
 531                 return;
 532
 533         bgscan_deinit(wpa_s);
 534         if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan) {
 535                 if (bgscan_init(wpa_s, wpa_s->current_ssid)) {
 536                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
 537                                 "bgscan");
 538                         /*
 539                          * Live without bgscan; it is only used as a roaming
 540                          * optimization, so the initial connection is not
 541                          * affected.
 542                          */
 543                 } else
 544                         wpa_s->bgscan_ssid = wpa_s->current_ssid;
 545         } else
 546                 wpa_s->bgscan_ssid = NULL;
 547 }
 548
 549
 550 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
 551 {
 552         if (wpa_s->bgscan_ssid != NULL) {
 553                 bgscan_deinit(wpa_s);
 554                 wpa_s->bgscan_ssid = NULL;
 555         }
 556 }
 557
 558 #endif /* CONFIG_BGSCAN */
 559
 560
 561 /**
 562  * wpa_supplicant_set_state - Set current connection state
 563  * @wpa_s: Pointer to wpa_supplicant data
 564  * @state: The new connection state
 565  *
 566  * This function is called whenever the connection state changes, e.g.,
 567  * association is completed for WPA/WPA2 4-Way Handshake is started.
 568  */
 569 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
 570                               enum wpa_states state)
 571 {
 572         enum wpa_states old_state = wpa_s->wpa_state;
 573
 574         wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
 575                 wpa_supplicant_state_txt(wpa_s->wpa_state),
 576                 wpa_supplicant_state_txt(state));
 577
 578         if (state != WPA_SCANNING)
 579                 wpa_supplicant_notify_scanning(wpa_s, 0);
 580
 581         if (state == WPA_COMPLETED && wpa_s->new_connection) {
 582 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 583                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 584                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
 585                         MACSTR " completed %s [id=%d id_str=%s]",
 586                         MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ?
 587                         "(reauth)" : "(auth)",
 588                         ssid ? ssid->id : -1,
 589                         ssid && ssid->id_str ? ssid->id_str : "");
 590 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 591                 wpa_s->new_connection = 0;
 592                 wpa_s->reassociated_connection = 1;
 593                 wpa_drv_set_operstate(wpa_s, 1);
 594 #ifndef IEEE8021X_EAPOL
 595                 wpa_drv_set_supp_port(wpa_s, 1);
 596 #endif /* IEEE8021X_EAPOL */
 597                 wpa_s->after_wps = 0;
 598 #ifdef CONFIG_P2P
 599                 wpas_p2p_completed(wpa_s);
 600 #endif /* CONFIG_P2P */
 601         } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
 602                    state == WPA_ASSOCIATED) {
 603                 wpa_s->new_connection = 1;
 604                 wpa_drv_set_operstate(wpa_s, 0);
 605 #ifndef IEEE8021X_EAPOL
 606                 wpa_drv_set_supp_port(wpa_s, 0);
 607 #endif /* IEEE8021X_EAPOL */
 608         }
 609         wpa_s->wpa_state = state;
 610
 611 #ifdef CONFIG_BGSCAN
 612         if (state == WPA_COMPLETED)
 613                 wpa_supplicant_start_bgscan(wpa_s);
 614         else
 615                 wpa_supplicant_stop_bgscan(wpa_s);
 616 #endif /* CONFIG_BGSCAN */
 617
 618         if (wpa_s->wpa_state != old_state) {
 619                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 620
 621                 if (wpa_s->wpa_state == WPA_COMPLETED ||
 622                     old_state == WPA_COMPLETED)
 623                         wpas_notify_auth_changed(wpa_s);
 624         }
 625 }
 626
 627
 628 void wpa_supplicant_terminate_proc(struct wpa_global *global)
 629 {
 630         int pending = 0;
 631 #ifdef CONFIG_WPS
 632         struct wpa_supplicant *wpa_s = global->ifaces;
 633         while (wpa_s) {
 634                 if (wpas_wps_terminate_pending(wpa_s) == 1)
 635                         pending = 1;
 636                 wpa_s = wpa_s->next;
 637         }
 638 #endif /* CONFIG_WPS */
 639         if (pending)
 640                 return;
 641         eloop_terminate();
 642 }
 643
 644
 645 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
 646 {
 647         struct wpa_global *global = signal_ctx;
 648         struct wpa_supplicant *wpa_s;
 649         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 650                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d "
 651                         "received", sig);
 652         }
 653         wpa_supplicant_terminate_proc(global);
 654 }
 655
 656
 657 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
 658 {
 659         enum wpa_states old_state = wpa_s->wpa_state;
 660
 661         wpa_s->pairwise_cipher = 0;
 662         wpa_s->group_cipher = 0;
 663         wpa_s->mgmt_group_cipher = 0;
 664         wpa_s->key_mgmt = 0;
 665         if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
 666                 wpa_s->wpa_state = WPA_DISCONNECTED;
 667
 668         if (wpa_s->wpa_state != old_state)
 669                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 670 }
 671
 672
 673 /**
 674  * wpa_supplicant_reload_configuration - Reload configuration data
 675  * @wpa_s: Pointer to wpa_supplicant data
 676  * Returns: 0 on success or -1 if configuration parsing failed
 677  *
 678  * This function can be used to request that the configuration data is reloaded
 679  * (e.g., after configuration file change). This function is reloading
 680  * configuration only for one interface, so this may need to be called multiple
 681  * times if %wpa_supplicant is controlling multiple interfaces and all
 682  * interfaces need reconfiguration.
 683  */
 684 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
 685 {
 686         struct wpa_config *conf;
 687         struct wpa_ssid *old_ssid;
 688         int reconf_ctrl;
 689         int old_ap_scan;
 690
 691         if (wpa_s->confname == NULL)
 692                 return -1;
 693         conf = wpa_config_read(wpa_s->confname);
 694         if (conf == NULL) {
 695                 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
 696                         "file '%s' - exiting", wpa_s->confname);
 697                 return -1;
 698         }
 699         conf->changed_parameters = (unsigned int) -1;
 700
 701         reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
 702                 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
 703                     os_strcmp(conf->ctrl_interface,
 704                               wpa_s->conf->ctrl_interface) != 0);
 705
 706         if (reconf_ctrl && wpa_s->ctrl_iface) {
 707                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 708                 wpa_s->ctrl_iface = NULL;
 709         }
 710
 711         eapol_sm_invalidate_cached_session(wpa_s->eapol);
 712         old_ssid = wpa_s->current_ssid;
 713         wpa_s->current_ssid = NULL;
 714         if (old_ssid != wpa_s->current_ssid)
 715                 wpas_notify_network_changed(wpa_s);
 716
 717         /*
 718          * TODO: should notify EAPOL SM about changes in opensc_engine_path,
 719          * pkcs11_engine_path, pkcs11_module_path.
 720          */
 721         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 722                 /*
 723                  * Clear forced success to clear EAP state for next
 724                  * authentication.
 725                  */
 726                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 727         }
 728         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
 729         wpa_sm_set_config(wpa_s->wpa, NULL);
 730         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
 731         rsn_preauth_deinit(wpa_s->wpa);
 732
 733         old_ap_scan = wpa_s->conf->ap_scan;
 734         wpa_config_free(wpa_s->conf);
 735         wpa_s->conf = conf;
 736         if (old_ap_scan != wpa_s->conf->ap_scan)
 737                 wpas_notify_ap_scan_changed(wpa_s);
 738
 739         if (reconf_ctrl)
 740                 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
 741
 742         wpa_supplicant_update_config(wpa_s);
 743
 744         wpa_supplicant_clear_status(wpa_s);
 745         if (wpa_supplicant_enabled_networks(wpa_s->conf)) {
 746                 wpa_s->reassociate = 1;
 747                 wpa_supplicant_req_scan(wpa_s, 0, 0);
 748         }
 749         wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
 750         return 0;
 751 }
 752
 753
 754 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
 755 {
 756         struct wpa_global *global = signal_ctx;
 757         struct wpa_supplicant *wpa_s;
 758         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 759                 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
 760                         sig);
 761                 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
 762                         wpa_supplicant_terminate_proc(global);
 763                 }
 764         }
 765 }
 766
 767
 768 enum wpa_cipher cipher_suite2driver(int cipher)
 769 {
 770         switch (cipher) {
 771         case WPA_CIPHER_NONE:
 772                 return CIPHER_NONE;
 773         case WPA_CIPHER_WEP40:
 774                 return CIPHER_WEP40;
 775         case WPA_CIPHER_WEP104:
 776                 return CIPHER_WEP104;
 777         case WPA_CIPHER_CCMP:
 778                 return CIPHER_CCMP;
 779         case WPA_CIPHER_TKIP:
 780         default:
 781                 return CIPHER_TKIP;
 782         }
 783 }
 784
 785
 786 enum wpa_key_mgmt key_mgmt2driver(int key_mgmt)
 787 {
 788         switch (key_mgmt) {
 789         case WPA_KEY_MGMT_NONE:
 790                 return KEY_MGMT_NONE;
 791         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
 792                 return KEY_MGMT_802_1X_NO_WPA;
 793         case WPA_KEY_MGMT_IEEE8021X:
 794                 return KEY_MGMT_802_1X;
 795         case WPA_KEY_MGMT_WPA_NONE:
 796                 return KEY_MGMT_WPA_NONE;
 797         case WPA_KEY_MGMT_FT_IEEE8021X:
 798                 return KEY_MGMT_FT_802_1X;
 799         case WPA_KEY_MGMT_FT_PSK:
 800                 return KEY_MGMT_FT_PSK;
 801         case WPA_KEY_MGMT_IEEE8021X_SHA256:
 802                 return KEY_MGMT_802_1X_SHA256;
 803         case WPA_KEY_MGMT_PSK_SHA256:
 804                 return KEY_MGMT_PSK_SHA256;
 805         case WPA_KEY_MGMT_WPS:
 806                 return KEY_MGMT_WPS;
 807         case WPA_KEY_MGMT_PSK:
 808         default:
 809                 return KEY_MGMT_PSK;
 810         }
 811 }
 812
 813
 814 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
 815                                          struct wpa_ssid *ssid,
 816                                          struct wpa_ie_data *ie)
 817 {
 818         int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
 819         if (ret) {
 820                 if (ret == -2) {
 821                         wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
 822                                 "from association info");
 823                 }
 824                 return -1;
 825         }
 826
 827         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
 828                 "cipher suites");
 829         if (!(ie->group_cipher & ssid->group_cipher)) {
 830                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
 831                         "cipher 0x%x (mask 0x%x) - reject",
 832                         ie->group_cipher, ssid->group_cipher);
 833                 return -1;
 834         }
 835         if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
 836                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
 837                         "cipher 0x%x (mask 0x%x) - reject",
 838                         ie->pairwise_cipher, ssid->pairwise_cipher);
 839                 return -1;
 840         }
 841         if (!(ie->key_mgmt & ssid->key_mgmt)) {
 842                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
 843                         "management 0x%x (mask 0x%x) - reject",
 844                         ie->key_mgmt, ssid->key_mgmt);
 845                 return -1;
 846         }
 847
 848 #ifdef CONFIG_IEEE80211W
 849         if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
 850             ssid->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED) {
 851                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
 852                         "that does not support management frame protection - "
 853                         "reject");
 854                 return -1;
 855         }
 856 #endif /* CONFIG_IEEE80211W */
 857
 858         return 0;
 859 }
 860
 861
 862 /**
 863  * wpa_supplicant_set_suites - Set authentication and encryption parameters
 864  * @wpa_s: Pointer to wpa_supplicant data
 865  * @bss: Scan results for the selected BSS, or %NULL if not available
 866  * @ssid: Configuration data for the selected network
 867  * @wpa_ie: Buffer for the WPA/RSN IE
 868  * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
 869  * used buffer length in case the functions returns success.
 870  * Returns: 0 on success or -1 on failure
 871  *
 872  * This function is used to configure authentication and encryption parameters
 873  * based on the network configuration and scan result for the selected BSS (if
 874  * available).
 875  */
 876 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
 877                               struct wpa_bss *bss, struct wpa_ssid *ssid,
 878                               u8 *wpa_ie, size_t *wpa_ie_len)
 879 {
 880         struct wpa_ie_data ie;
 881         int sel, proto;
 882         const u8 *bss_wpa, *bss_rsn;
 883
 884         if (bss) {
 885                 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
 886                 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
 887         } else
 888                 bss_wpa = bss_rsn = NULL;
 889
 890         if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
 891             wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
 892             (ie.group_cipher & ssid->group_cipher) &&
 893             (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 894             (ie.key_mgmt & ssid->key_mgmt)) {
 895                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
 896                 proto = WPA_PROTO_RSN;
 897         } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
 898                    wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
 899                    (ie.group_cipher & ssid->group_cipher) &&
 900                    (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 901                    (ie.key_mgmt & ssid->key_mgmt)) {
 902                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
 903                 proto = WPA_PROTO_WPA;
 904         } else if (bss) {
 905                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
 906                 return -1;
 907         } else {
 908                 if (ssid->proto & WPA_PROTO_RSN)
 909                         proto = WPA_PROTO_RSN;
 910                 else
 911                         proto = WPA_PROTO_WPA;
 912                 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
 913                         os_memset(&ie, 0, sizeof(ie));
 914                         ie.group_cipher = ssid->group_cipher;
 915                         ie.pairwise_cipher = ssid->pairwise_cipher;
 916                         ie.key_mgmt = ssid->key_mgmt;
 917 #ifdef CONFIG_IEEE80211W
 918                         ie.mgmt_group_cipher =
 919                                 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
 920                                 WPA_CIPHER_AES_128_CMAC : 0;
 921 #endif /* CONFIG_IEEE80211W */
 922                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
 923                                 "based on configuration");
 924                 } else
 925                         proto = ie.proto;
 926         }
 927
 928         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
 929                 "pairwise %d key_mgmt %d proto %d",
 930                 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
 931 #ifdef CONFIG_IEEE80211W
 932         if (ssid->ieee80211w) {
 933                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
 934                         ie.mgmt_group_cipher);
 935         }
 936 #endif /* CONFIG_IEEE80211W */
 937
 938         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
 939         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
 940                          !!(ssid->proto & WPA_PROTO_RSN));
 941
 942         if (bss || !wpa_s->ap_ies_from_associnfo) {
 943                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
 944                                          bss_wpa ? 2 + bss_wpa[1] : 0) ||
 945                     wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
 946                                          bss_rsn ? 2 + bss_rsn[1] : 0))
 947                         return -1;
 948         }
 949
 950         sel = ie.group_cipher & ssid->group_cipher;
 951         if (sel & WPA_CIPHER_CCMP) {
 952                 wpa_s->group_cipher = WPA_CIPHER_CCMP;
 953                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP");
 954         } else if (sel & WPA_CIPHER_TKIP) {
 955                 wpa_s->group_cipher = WPA_CIPHER_TKIP;
 956                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP");
 957         } else if (sel & WPA_CIPHER_WEP104) {
 958                 wpa_s->group_cipher = WPA_CIPHER_WEP104;
 959                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104");
 960         } else if (sel & WPA_CIPHER_WEP40) {
 961                 wpa_s->group_cipher = WPA_CIPHER_WEP40;
 962                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40");
 963         } else {
 964                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
 965                         "cipher");
 966                 return -1;
 967         }
 968
 969         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
 970         if (sel & WPA_CIPHER_CCMP) {
 971                 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
 972                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP");
 973         } else if (sel & WPA_CIPHER_TKIP) {
 974                 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
 975                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP");
 976         } else if (sel & WPA_CIPHER_NONE) {
 977                 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 978                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE");
 979         } else {
 980                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
 981                         "cipher");
 982                 return -1;
 983         }
 984
 985         sel = ie.key_mgmt & ssid->key_mgmt;
 986         if (0) {
 987 #ifdef CONFIG_IEEE80211R
 988         } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
 989                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
 990                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
 991         } else if (sel & WPA_KEY_MGMT_FT_PSK) {
 992                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
 993                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
 994 #endif /* CONFIG_IEEE80211R */
 995 #ifdef CONFIG_IEEE80211W
 996         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
 997                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
 998                 wpa_dbg(wpa_s, MSG_DEBUG,
 999                         "WPA: using KEY_MGMT 802.1X with SHA256");
1000         } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1001                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1002                 wpa_dbg(wpa_s, MSG_DEBUG,
1003                         "WPA: using KEY_MGMT PSK with SHA256");
1004 #endif /* CONFIG_IEEE80211W */
1005         } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1006                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1007                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1008         } else if (sel & WPA_KEY_MGMT_PSK) {
1009                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1010                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1011         } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1012                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1013                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1014         } else {
1015                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1016                         "authenticated key management type");
1017                 return -1;
1018         }
1019
1020         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1021         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1022                          wpa_s->pairwise_cipher);
1023         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1024
1025 #ifdef CONFIG_IEEE80211W
1026         sel = ie.mgmt_group_cipher;
1027         if (ssid->ieee80211w == NO_MGMT_FRAME_PROTECTION ||
1028             !(ie.capabilities & WPA_CAPABILITY_MFPC))
1029                 sel = 0;
1030         if (sel & WPA_CIPHER_AES_128_CMAC) {
1031                 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1032                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1033                         "AES-128-CMAC");
1034         } else {
1035                 wpa_s->mgmt_group_cipher = 0;
1036                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1037         }
1038         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1039                          wpa_s->mgmt_group_cipher);
1040         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, ssid->ieee80211w);
1041 #endif /* CONFIG_IEEE80211W */
1042
1043         if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1044                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1045                 return -1;
1046         }
1047
1048         if (ssid->key_mgmt &
1049             (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_FT_PSK | WPA_KEY_MGMT_PSK_SHA256))
1050                 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
1051         else
1052                 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1053
1054         return 0;
1055 }
1056
1057
1058 /**
1059  * wpa_supplicant_associate - Request association
1060  * @wpa_s: Pointer to wpa_supplicant data
1061  * @bss: Scan results for the selected BSS, or %NULL if not available
1062  * @ssid: Configuration data for the selected network
1063  *
1064  * This function is used to request %wpa_supplicant to associate with a BSS.
1065  */
1066 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1067                               struct wpa_bss *bss, struct wpa_ssid *ssid)
1068 {
1069         u8 wpa_ie[200];
1070         size_t wpa_ie_len;
1071         int use_crypt, ret, i, bssid_changed;
1072         int algs = WPA_AUTH_ALG_OPEN;
1073         enum wpa_cipher cipher_pairwise, cipher_group;
1074         struct wpa_driver_associate_params params;
1075         int wep_keys_set = 0;
1076         struct wpa_driver_capa capa;
1077         int assoc_failed = 0;
1078         struct wpa_ssid *old_ssid;
1079
1080 #ifdef CONFIG_IBSS_RSN
1081         ibss_rsn_deinit(wpa_s->ibss_rsn);
1082         wpa_s->ibss_rsn = NULL;
1083 #endif /* CONFIG_IBSS_RSN */
1084
1085         if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1086             ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1087 #ifdef CONFIG_AP
1088                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1089                         wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1090                                 "mode");
1091                         return;
1092                 }
1093                 wpa_supplicant_create_ap(wpa_s, ssid);
1094                 wpa_s->current_bss = bss;
1095 #else /* CONFIG_AP */
1096                 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1097                         "the build");
1098 #endif /* CONFIG_AP */
1099                 return;
1100         }
1101
1102 #ifdef CONFIG_TDLS
1103         wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1), bss->ie_len);
1104 #endif /* CONFIG_TDLS */
1105
1106         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1107             ssid->mode == IEEE80211_MODE_INFRA) {
1108                 sme_authenticate(wpa_s, bss, ssid);
1109                 return;
1110         }
1111
1112         os_memset(&params, 0, sizeof(params));
1113         wpa_s->reassociate = 0;
1114         if (bss) {
1115 #ifdef CONFIG_IEEE80211R
1116                 const u8 *ie, *md = NULL;
1117 #endif /* CONFIG_IEEE80211R */
1118                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1119                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
1120                         wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
1121                 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1122                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1123                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1124                 if (bssid_changed)
1125                         wpas_notify_bssid_changed(wpa_s);
1126 #ifdef CONFIG_IEEE80211R
1127                 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
1128                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1129                         md = ie + 2;
1130                 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1131                 if (md) {
1132                         /* Prepare for the next transition */
1133                         wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1134                 }
1135 #endif /* CONFIG_IEEE80211R */
1136 #ifdef CONFIG_WPS
1137         } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1138                    wpa_s->conf->ap_scan == 2 &&
1139                    (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1140                 /* Use ap_scan==1 style network selection to find the network
1141                  */
1142                 wpa_s->scan_req = 2;
1143                 wpa_s->reassociate = 1;
1144                 wpa_supplicant_req_scan(wpa_s, 0, 0);
1145                 return;
1146 #endif /* CONFIG_WPS */
1147         } else {
1148                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1149                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1150                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1151         }
1152         wpa_supplicant_cancel_scan(wpa_s);
1153
1154         /* Starting new association, so clear the possibly used WPA IE from the
1155          * previous association. */
1156         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1157
1158 #ifdef IEEE8021X_EAPOL
1159         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1160                 if (ssid->leap) {
1161                         if (ssid->non_leap == 0)
1162                                 algs = WPA_AUTH_ALG_LEAP;
1163                         else
1164                                 algs |= WPA_AUTH_ALG_LEAP;
1165                 }
1166         }
1167 #endif /* IEEE8021X_EAPOL */
1168         wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1169         if (ssid->auth_alg) {
1170                 algs = ssid->auth_alg;
1171                 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1172                         "0x%x", algs);
1173         }
1174
1175         if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1176                     wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
1177             (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |
1178                                WPA_KEY_MGMT_FT_IEEE8021X |
1179                                WPA_KEY_MGMT_FT_PSK |
1180                                WPA_KEY_MGMT_IEEE8021X_SHA256 |
1181                                WPA_KEY_MGMT_PSK_SHA256))) {
1182                 int try_opportunistic;
1183                 try_opportunistic = ssid->proactive_key_caching &&
1184                         (ssid->proto & WPA_PROTO_RSN);
1185                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1186                                             wpa_s->current_ssid,
1187                                             try_opportunistic) == 0)
1188                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1189                 wpa_ie_len = sizeof(wpa_ie);
1190                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1191                                               wpa_ie, &wpa_ie_len)) {
1192                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1193                                 "key management and encryption suites");
1194                         return;
1195                 }
1196         } else if (ssid->key_mgmt &
1197                    (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X |
1198                     WPA_KEY_MGMT_WPA_NONE | WPA_KEY_MGMT_FT_PSK |
1199                     WPA_KEY_MGMT_FT_IEEE8021X | WPA_KEY_MGMT_PSK_SHA256 |
1200                     WPA_KEY_MGMT_IEEE8021X_SHA256)) {
1201                 wpa_ie_len = sizeof(wpa_ie);
1202                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1203                                               wpa_ie, &wpa_ie_len)) {
1204                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1205                                 "key management and encryption suites (no "
1206                                 "scan results)");
1207                         return;
1208                 }
1209 #ifdef CONFIG_WPS
1210         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
1211                 struct wpabuf *wps_ie;
1212                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
1213                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1214                         wpa_ie_len = wpabuf_len(wps_ie);
1215                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
1216                 } else
1217                         wpa_ie_len = 0;
1218                 wpabuf_free(wps_ie);
1219                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1220                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1221                         params.wps = WPS_MODE_PRIVACY;
1222                 else
1223                         params.wps = WPS_MODE_OPEN;
1224 #endif /* CONFIG_WPS */
1225         } else {
1226                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1227                 wpa_ie_len = 0;
1228         }
1229
1230 #ifdef CONFIG_P2P
1231         if (wpa_s->global->p2p) {
1232                 u8 *pos;
1233                 size_t len;
1234                 int res;
1235                 int p2p_group;
1236                 p2p_group = wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE;
1237                 pos = wpa_ie + wpa_ie_len;
1238                 len = sizeof(wpa_ie) - wpa_ie_len;
1239                 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len, p2p_group);
1240                 if (res >= 0)
1241                         wpa_ie_len += res;
1242         }
1243
1244         wpa_s->cross_connect_disallowed = 0;
1245         if (bss) {
1246                 struct wpabuf *p2p;
1247                 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1248                 if (p2p) {
1249                         wpa_s->cross_connect_disallowed =
1250                                 p2p_get_cross_connect_disallowed(p2p);
1251                         wpabuf_free(p2p);
1252                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1253                                 "connection",
1254                                 wpa_s->cross_connect_disallowed ?
1255                                 "disallows" : "allows");
1256                 }
1257         }
1258 #endif /* CONFIG_P2P */
1259
1260         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1261         use_crypt = 1;
1262         cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher);
1263         cipher_group = cipher_suite2driver(wpa_s->group_cipher);
1264         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1265             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1266                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1267                         use_crypt = 0;
1268                 if (wpa_set_wep_keys(wpa_s, ssid)) {
1269                         use_crypt = 1;
1270                         wep_keys_set = 1;
1271                 }
1272         }
1273         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1274                 use_crypt = 0;
1275
1276 #ifdef IEEE8021X_EAPOL
1277         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1278                 if ((ssid->eapol_flags &
1279                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1280                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1281                     !wep_keys_set) {
1282                         use_crypt = 0;
1283                 } else {
1284                         /* Assume that dynamic WEP-104 keys will be used and
1285                          * set cipher suites in order for drivers to expect
1286                          * encryption. */
1287                         cipher_pairwise = cipher_group = CIPHER_WEP104;
1288                 }
1289         }
1290 #endif /* IEEE8021X_EAPOL */
1291
1292         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1293                 /* Set the key before (and later after) association */
1294                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1295         }
1296
1297         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1298         if (bss) {
1299                 params.bssid = bss->bssid;
1300                 params.ssid = bss->ssid;
1301                 params.ssid_len = bss->ssid_len;
1302                 params.freq = bss->freq;
1303         } else {
1304                 params.ssid = ssid->ssid;
1305                 params.ssid_len = ssid->ssid_len;
1306         }
1307         if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
1308             params.freq == 0)
1309                 params.freq = ssid->frequency; /* Initial channel for IBSS */
1310         params.wpa_ie = wpa_ie;
1311         params.wpa_ie_len = wpa_ie_len;
1312         params.pairwise_suite = cipher_pairwise;
1313         params.group_suite = cipher_group;
1314         params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1315         params.auth_alg = algs;
1316         params.mode = ssid->mode;
1317         for (i = 0; i < NUM_WEP_KEYS; i++) {
1318                 if (ssid->wep_key_len[i])
1319                         params.wep_key[i] = ssid->wep_key[i];
1320                 params.wep_key_len[i] = ssid->wep_key_len[i];
1321         }
1322         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1323
1324         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1325             (params.key_mgmt_suite == KEY_MGMT_PSK ||
1326              params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1327                 params.passphrase = ssid->passphrase;
1328                 if (ssid->psk_set)
1329                         params.psk = ssid->psk;
1330         }
1331
1332         params.drop_unencrypted = use_crypt;
1333
1334 #ifdef CONFIG_IEEE80211W
1335         params.mgmt_frame_protection = ssid->ieee80211w;
1336         if (ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION && bss) {
1337                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1338                 struct wpa_ie_data ie;
1339                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1340                     ie.capabilities &
1341                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1342                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1343                                 "MFP: require MFP");
1344                         params.mgmt_frame_protection =
1345                                 MGMT_FRAME_PROTECTION_REQUIRED;
1346                 }
1347         }
1348 #endif /* CONFIG_IEEE80211W */
1349
1350 #ifdef CONFIG_P2P
1351         if (wpa_s->global->p2p &&
1352             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
1353                 params.p2p = 1;
1354 #endif /* CONFIG_P2P */
1355
1356         if (wpa_s->parent->set_sta_uapsd)
1357                 params.uapsd = wpa_s->parent->sta_uapsd;
1358         else
1359                 params.uapsd = -1;
1360
1361         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1362                 ret = ieee80211_sta_associate(wpa_s, &params);
1363         else
1364                 ret = wpa_drv_associate(wpa_s, &params);
1365         if (ret < 0) {
1366                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1367                         "failed");
1368                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1369                         /*
1370                          * The driver is known to mean what is saying, so we
1371                          * can stop right here; the association will not
1372                          * succeed.
1373                          */
1374                         wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
1375                         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1376                         return;
1377                 }
1378                 /* try to continue anyway; new association will be tried again
1379                  * after timeout */
1380                 assoc_failed = 1;
1381         }
1382
1383         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1384                 /* Set the key after the association just in case association
1385                  * cleared the previously configured key. */
1386                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1387                 /* No need to timeout authentication since there is no key
1388                  * management. */
1389                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1390                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1391 #ifdef CONFIG_IBSS_RSN
1392         } else if (ssid->mode == WPAS_MODE_IBSS &&
1393                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1394                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1395                 /*
1396                  * RSN IBSS authentication is per-STA and we can disable the
1397                  * per-BSSID authentication.
1398                  */
1399                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1400 #endif /* CONFIG_IBSS_RSN */
1401         } else {
1402                 /* Timeout for IEEE 802.11 authentication and association */
1403                 int timeout = 60;
1404
1405                 if (assoc_failed) {
1406                         /* give IBSS a bit more time */
1407                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
1408                 } else if (wpa_s->conf->ap_scan == 1) {
1409                         /* give IBSS a bit more time */
1410                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
1411                 }
1412                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1413         }
1414
1415         if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1416             capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1417                 /* Set static WEP keys again */
1418                 wpa_set_wep_keys(wpa_s, ssid);
1419         }
1420
1421         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1422                 /*
1423                  * Do not allow EAP session resumption between different
1424                  * network configurations.
1425                  */
1426                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1427         }
1428         old_ssid = wpa_s->current_ssid;
1429         wpa_s->current_ssid = ssid;
1430         wpa_s->current_bss = bss;
1431         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1432         wpa_supplicant_initiate_eapol(wpa_s);
1433         if (old_ssid != wpa_s->current_ssid)
1434                 wpas_notify_network_changed(wpa_s);
1435 }
1436
1437
1438 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1439                                             const u8 *addr)
1440 {
1441         struct wpa_ssid *old_ssid;
1442
1443         wpa_clear_keys(wpa_s, addr);
1444         wpa_supplicant_mark_disassoc(wpa_s);
1445         old_ssid = wpa_s->current_ssid;
1446         wpa_s->current_ssid = NULL;
1447         wpa_s->current_bss = NULL;
1448         wpa_sm_set_config(wpa_s->wpa, NULL);
1449         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1450         if (old_ssid != wpa_s->current_ssid)
1451                 wpas_notify_network_changed(wpa_s);
1452         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1453 }
1454
1455
1456 /**
1457  * wpa_supplicant_disassociate - Disassociate the current connection
1458  * @wpa_s: Pointer to wpa_supplicant data
1459  * @reason_code: IEEE 802.11 reason code for the disassociate frame
1460  *
1461  * This function is used to request %wpa_supplicant to disassociate with the
1462  * current AP.
1463  */
1464 void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1465                                  int reason_code)
1466 {
1467         u8 *addr = NULL;
1468
1469         if (!is_zero_ether_addr(wpa_s->bssid)) {
1470                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1471                         ieee80211_sta_disassociate(wpa_s, reason_code);
1472                 else
1473                         wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1474                 addr = wpa_s->bssid;
1475         }
1476
1477         wpa_supplicant_clear_connection(wpa_s, addr);
1478 }
1479
1480
1481 /**
1482  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1483  * @wpa_s: Pointer to wpa_supplicant data
1484  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1485  *
1486  * This function is used to request %wpa_supplicant to deauthenticate from the
1487  * current AP.
1488  */
1489 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1490                                    int reason_code)
1491 {
1492         u8 *addr = NULL;
1493
1494         if (!is_zero_ether_addr(wpa_s->bssid)) {
1495                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1496                         ieee80211_sta_deauthenticate(wpa_s, reason_code);
1497                 else
1498                         wpa_drv_deauthenticate(wpa_s, wpa_s->bssid,
1499                                                reason_code);
1500                 addr = wpa_s->bssid;
1501         }
1502
1503         wpa_supplicant_clear_connection(wpa_s, addr);
1504 }
1505
1506
1507 /**
1508  * wpa_supplicant_enable_network - Mark a configured network as enabled
1509  * @wpa_s: wpa_supplicant structure for a network interface
1510  * @ssid: wpa_ssid structure for a configured network or %NULL
1511  *
1512  * Enables the specified network or all networks if no network specified.
1513  */
1514 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
1515                                    struct wpa_ssid *ssid)
1516 {
1517         struct wpa_ssid *other_ssid;
1518         int was_disabled;
1519
1520         if (ssid == NULL) {
1521                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1522                      other_ssid = other_ssid->next) {
1523                         if (other_ssid->disabled == 2)
1524                                 continue; /* do not change persistent P2P group
1525                                            * data */
1526                         if (other_ssid == wpa_s->current_ssid &&
1527                             other_ssid->disabled)
1528                                 wpa_s->reassociate = 1;
1529
1530                         was_disabled = other_ssid->disabled;
1531
1532                         other_ssid->disabled = 0;
1533
1534                         if (was_disabled != other_ssid->disabled)
1535                                 wpas_notify_network_enabled_changed(
1536                                         wpa_s, other_ssid);
1537                 }
1538                 if (wpa_s->reassociate)
1539                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1540         } else if (ssid->disabled && ssid->disabled != 2) {
1541                 if (wpa_s->current_ssid == NULL) {
1542                         /*
1543                          * Try to reassociate since there is no current
1544                          * configuration and a new network was made available.
1545                          */
1546                         wpa_s->reassociate = 1;
1547                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1548                 }
1549
1550                 was_disabled = ssid->disabled;
1551
1552                 ssid->disabled = 0;
1553
1554                 if (was_disabled != ssid->disabled)
1555                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1556         }
1557 }
1558
1559
1560 /**
1561  * wpa_supplicant_disable_network - Mark a configured network as disabled
1562  * @wpa_s: wpa_supplicant structure for a network interface
1563  * @ssid: wpa_ssid structure for a configured network or %NULL
1564  *
1565  * Disables the specified network or all networks if no network specified.
1566  */
1567 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
1568                                     struct wpa_ssid *ssid)
1569 {
1570         struct wpa_ssid *other_ssid;
1571         int was_disabled;
1572
1573         if (ssid == NULL) {
1574                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1575                      other_ssid = other_ssid->next) {
1576                         was_disabled = other_ssid->disabled;
1577                         if (was_disabled == 2)
1578                                 continue; /* do not change persistent P2P group
1579                                            * data */
1580
1581                         other_ssid->disabled = 1;
1582
1583                         if (was_disabled != other_ssid->disabled)
1584                                 wpas_notify_network_enabled_changed(
1585                                         wpa_s, other_ssid);
1586                 }
1587                 if (wpa_s->current_ssid)
1588                         wpa_supplicant_disassociate(
1589                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1590         } else if (ssid->disabled != 2) {
1591                 if (ssid == wpa_s->current_ssid)
1592                         wpa_supplicant_disassociate(
1593                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1594
1595                 was_disabled = ssid->disabled;
1596
1597                 ssid->disabled = 1;
1598
1599                 if (was_disabled != ssid->disabled)
1600                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1601         }
1602 }
1603
1604
1605 /**
1606  * wpa_supplicant_select_network - Attempt association with a network
1607  * @wpa_s: wpa_supplicant structure for a network interface
1608  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
1609  */
1610 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
1611                                    struct wpa_ssid *ssid)
1612 {
1613
1614         struct wpa_ssid *other_ssid;
1615
1616         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid)
1617                 wpa_supplicant_disassociate(
1618                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1619
1620         /*
1621          * Mark all other networks disabled or mark all networks enabled if no
1622          * network specified.
1623          */
1624         for (other_ssid = wpa_s->conf->ssid; other_ssid;
1625              other_ssid = other_ssid->next) {
1626                 int was_disabled = other_ssid->disabled;
1627                 if (was_disabled == 2)
1628                         continue; /* do not change persistent P2P group data */
1629
1630                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
1631
1632                 if (was_disabled != other_ssid->disabled)
1633                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
1634         }
1635         wpa_s->disconnected = 0;
1636         wpa_s->reassociate = 1;
1637         wpa_supplicant_req_scan(wpa_s, 0, 0);
1638
1639         if (ssid)
1640                 wpas_notify_network_selected(wpa_s, ssid);
1641 }
1642
1643
1644 /**
1645  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
1646  * @wpa_s: wpa_supplicant structure for a network interface
1647  * @ap_scan: AP scan mode
1648  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
1649  *
1650  */
1651 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
1652 {
1653
1654         int old_ap_scan;
1655
1656         if (ap_scan < 0 || ap_scan > 2)
1657                 return -1;
1658
1659         old_ap_scan = wpa_s->conf->ap_scan;
1660         wpa_s->conf->ap_scan = ap_scan;
1661
1662         if (old_ap_scan != wpa_s->conf->ap_scan)
1663                 wpas_notify_ap_scan_changed(wpa_s);
1664
1665         return 0;
1666 }
1667
1668
1669 /**
1670  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
1671  * @wpa_s: wpa_supplicant structure for a network interface
1672  * @expire_age: Expiration age in seconds
1673  * Returns: 0 if succeed or -1 if expire_age has an invalid value
1674  *
1675  */
1676 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
1677                                           unsigned int bss_expire_age)
1678 {
1679         if (bss_expire_age < 10) {
1680                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
1681                         bss_expire_age);
1682                 return -1;
1683         }
1684         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
1685                 bss_expire_age);
1686         wpa_s->conf->bss_expiration_age = bss_expire_age;
1687
1688         return 0;
1689 }
1690
1691
1692 /**
1693  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
1694  * @wpa_s: wpa_supplicant structure for a network interface
1695  * @expire_count: number of scans after which an unseen BSS is reclaimed
1696  * Returns: 0 if succeed or -1 if expire_count has an invalid value
1697  *
1698  */
1699 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
1700                                             unsigned int bss_expire_count)
1701 {
1702         if (bss_expire_count < 1) {
1703                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
1704                         bss_expire_count);
1705                 return -1;
1706         }
1707         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
1708                 bss_expire_count);
1709         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
1710
1711         return 0;
1712 }
1713
1714
1715 /**
1716  * wpa_supplicant_set_debug_params - Set global debug params
1717  * @global: wpa_global structure
1718  * @debug_level: debug level
1719  * @debug_timestamp: determines if show timestamp in debug data
1720  * @debug_show_keys: determines if show keys in debug data
1721  * Returns: 0 if succeed or -1 if debug_level has wrong value
1722  */
1723 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
1724                                     int debug_timestamp, int debug_show_keys)
1725 {
1726
1727         int old_level, old_timestamp, old_show_keys;
1728
1729         /* check for allowed debuglevels */
1730         if (debug_level != MSG_EXCESSIVE &&
1731             debug_level != MSG_MSGDUMP &&
1732             debug_level != MSG_DEBUG &&
1733             debug_level != MSG_INFO &&
1734             debug_level != MSG_WARNING &&
1735             debug_level != MSG_ERROR)
1736                 return -1;
1737
1738         old_level = wpa_debug_level;
1739         old_timestamp = wpa_debug_timestamp;
1740         old_show_keys = wpa_debug_show_keys;
1741
1742         wpa_debug_level = debug_level;
1743         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
1744         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
1745
1746         if (wpa_debug_level != old_level)
1747                 wpas_notify_debug_level_changed(global);
1748         if (wpa_debug_timestamp != old_timestamp)
1749                 wpas_notify_debug_timestamp_changed(global);
1750         if (wpa_debug_show_keys != old_show_keys)
1751                 wpas_notify_debug_show_keys_changed(global);
1752
1753         return 0;
1754 }
1755
1756
1757 /**
1758  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
1759  * @wpa_s: Pointer to wpa_supplicant data
1760  * Returns: A pointer to the current network structure or %NULL on failure
1761  */
1762 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
1763 {
1764         struct wpa_ssid *entry;
1765         u8 ssid[MAX_SSID_LEN];
1766         int res;
1767         size_t ssid_len;
1768         u8 bssid[ETH_ALEN];
1769         int wired;
1770
1771         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
1772                 if (ieee80211_sta_get_ssid(wpa_s, ssid, &ssid_len)) {
1773                         wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
1774                                 "MLME");
1775                         return NULL;
1776                 }
1777         } else {
1778                 res = wpa_drv_get_ssid(wpa_s, ssid);
1779                 if (res < 0) {
1780                         wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
1781                                 "driver");
1782                         return NULL;
1783                 }
1784                 ssid_len = res;
1785         }
1786
1787         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1788                 os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
1789         else if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
1790                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
1791                         "driver");
1792                 return NULL;
1793         }
1794
1795         wired = wpa_s->conf->ap_scan == 0 &&
1796                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
1797
1798         entry = wpa_s->conf->ssid;
1799         while (entry) {
1800                 if (!entry->disabled &&
1801                     ((ssid_len == entry->ssid_len &&
1802                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
1803                     (!entry->bssid_set ||
1804                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1805                         return entry;
1806 #ifdef CONFIG_WPS
1807                 if (!entry->disabled &&
1808                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
1809                     (entry->ssid == NULL || entry->ssid_len == 0) &&
1810                     (!entry->bssid_set ||
1811                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1812                         return entry;
1813 #endif /* CONFIG_WPS */
1814                 entry = entry->next;
1815         }
1816
1817         return NULL;
1818 }
1819
1820
1821 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
1822                                      const char *name)
1823 {
1824         int i;
1825         size_t len;
1826         const char *pos, *driver = name;
1827
1828         if (wpa_s == NULL)
1829                 return -1;
1830
1831         if (wpa_drivers[0] == NULL) {
1832                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
1833                         "wpa_supplicant");
1834                 return -1;
1835         }
1836
1837         if (name == NULL) {
1838                 /* default to first driver in the list */
1839                 wpa_s->driver = wpa_drivers[0];
1840                 wpa_s->global_drv_priv = wpa_s->global->drv_priv[0];
1841                 return 0;
1842         }
1843
1844         do {
1845                 pos = os_strchr(driver, ',');
1846                 if (pos)
1847                         len = pos - driver;
1848                 else
1849                         len = os_strlen(driver);
1850
1851                 for (i = 0; wpa_drivers[i]; i++) {
1852                         if (os_strlen(wpa_drivers[i]->name) == len &&
1853                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
1854                             0) {
1855                                 wpa_s->driver = wpa_drivers[i];
1856                                 wpa_s->global_drv_priv =
1857                                         wpa_s->global->drv_priv[i];
1858                                 return 0;
1859                         }
1860                 }
1861
1862                 driver = pos + 1;
1863         } while (pos);
1864
1865         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
1866         return -1;
1867 }
1868
1869
1870 /**
1871  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
1872  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
1873  *      with struct wpa_driver_ops::init()
1874  * @src_addr: Source address of the EAPOL frame
1875  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
1876  * @len: Length of the EAPOL data
1877  *
1878  * This function is called for each received EAPOL frame. Most driver
1879  * interfaces rely on more generic OS mechanism for receiving frames through
1880  * l2_packet, but if such a mechanism is not available, the driver wrapper may
1881  * take care of received EAPOL frames and deliver them to the core supplicant
1882  * code by calling this function.
1883  */
1884 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1885                              const u8 *buf, size_t len)
1886 {
1887         struct wpa_supplicant *wpa_s = ctx;
1888
1889         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
1890         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
1891
1892         if (wpa_s->wpa_state < WPA_ASSOCIATED) {
1893                 /*
1894                  * There is possible race condition between receiving the
1895                  * association event and the EAPOL frame since they are coming
1896                  * through different paths from the driver. In order to avoid
1897                  * issues in trying to process the EAPOL frame before receiving
1898                  * association information, lets queue it for processing until
1899                  * the association event is received.
1900                  */
1901                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
1902                         "of received EAPOL frame");
1903                 wpabuf_free(wpa_s->pending_eapol_rx);
1904                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
1905                 if (wpa_s->pending_eapol_rx) {
1906                         os_get_time(&wpa_s->pending_eapol_rx_time);
1907                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
1908                                   ETH_ALEN);
1909                 }
1910                 return;
1911         }
1912
1913 #ifdef CONFIG_AP
1914         if (wpa_s->ap_iface) {
1915                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
1916                 return;
1917         }
1918 #endif /* CONFIG_AP */
1919
1920         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
1921                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
1922                         "no key management is configured");
1923                 return;
1924         }
1925
1926         if (wpa_s->eapol_received == 0 &&
1927             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
1928              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
1929              wpa_s->wpa_state != WPA_COMPLETED) &&
1930             (wpa_s->current_ssid == NULL ||
1931              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
1932                 /* Timeout for completing IEEE 802.1X and WPA authentication */
1933                 wpa_supplicant_req_auth_timeout(
1934                         wpa_s,
1935                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
1936                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
1937                          wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
1938                         70 : 10, 0);
1939         }
1940         wpa_s->eapol_received++;
1941
1942         if (wpa_s->countermeasures) {
1943                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
1944                         "EAPOL packet");
1945                 return;
1946         }
1947
1948 #ifdef CONFIG_IBSS_RSN
1949         if (wpa_s->current_ssid &&
1950             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
1951                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
1952                 return;
1953         }
1954 #endif /* CONFIG_IBSS_RSN */
1955
1956         /* Source address of the incoming EAPOL frame could be compared to the
1957          * current BSSID. However, it is possible that a centralized
1958          * Authenticator could be using another MAC address than the BSSID of
1959          * an AP, so just allow any address to be used for now. The replies are
1960          * still sent to the current BSSID (if available), though. */
1961
1962         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
1963         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
1964             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
1965                 return;
1966         wpa_drv_poll(wpa_s);
1967         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
1968                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
1969         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
1970                 /*
1971                  * Set portValid = TRUE here since we are going to skip 4-way
1972                  * handshake processing which would normally set portValid. We
1973                  * need this to allow the EAPOL state machines to be completed
1974                  * without going through EAPOL-Key handshake.
1975                  */
1976                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1977         }
1978 }
1979
1980
1981 /**
1982  * wpa_supplicant_driver_init - Initialize driver interface parameters
1983  * @wpa_s: Pointer to wpa_supplicant data
1984  * Returns: 0 on success, -1 on failure
1985  *
1986  * This function is called to initialize driver interface parameters.
1987  * wpa_drv_init() must have been called before this function to initialize the
1988  * driver interface.
1989  */
1990 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
1991 {
1992         static int interface_count = 0;
1993
1994         if (wpa_s->driver->send_eapol) {
1995                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
1996                 if (addr)
1997                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
1998         } else if (!(wpa_s->drv_flags &
1999                      WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
2000                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2001                                            wpa_drv_get_mac_addr(wpa_s),
2002                                            ETH_P_EAPOL,
2003                                            wpa_supplicant_rx_eapol, wpa_s, 0);
2004                 if (wpa_s->l2 == NULL)
2005                         return -1;
2006         } else {
2007                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2008                 if (addr)
2009                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2010         }
2011
2012         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2013                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2014                 return -1;
2015         }
2016
2017         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2018                 MAC2STR(wpa_s->own_addr));
2019
2020         if (wpa_s->bridge_ifname[0]) {
2021                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2022                         "interface '%s'", wpa_s->bridge_ifname);
2023                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2024                                               wpa_s->own_addr,
2025                                               ETH_P_EAPOL,
2026                                               wpa_supplicant_rx_eapol, wpa_s,
2027                                               0);
2028                 if (wpa_s->l2_br == NULL) {
2029                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2030                                 "connection for the bridge interface '%s'",
2031                                 wpa_s->bridge_ifname);
2032                         return -1;
2033                 }
2034         }
2035
2036         wpa_clear_keys(wpa_s, NULL);
2037
2038         /* Make sure that TKIP countermeasures are not left enabled (could
2039          * happen if wpa_supplicant is killed during countermeasures. */
2040         wpa_drv_set_countermeasures(wpa_s, 0);
2041
2042         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2043         wpa_drv_flush_pmkid(wpa_s);
2044
2045         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2046         if (wpa_supplicant_enabled_networks(wpa_s->conf)) {
2047                 wpa_supplicant_req_scan(wpa_s, interface_count, 100000);
2048                 interface_count++;
2049         } else
2050                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2051
2052         return 0;
2053 }
2054
2055
2056 static int wpa_supplicant_daemon(const char *pid_file)
2057 {
2058         wpa_printf(MSG_DEBUG, "Daemonize..");
2059         return os_daemonize(pid_file);
2060 }
2061
2062
2063 static struct wpa_supplicant * wpa_supplicant_alloc(void)
2064 {
2065         struct wpa_supplicant *wpa_s;
2066
2067         wpa_s = os_zalloc(sizeof(*wpa_s));
2068         if (wpa_s == NULL)
2069                 return NULL;
2070         wpa_s->scan_req = 1;
2071         wpa_s->new_connection = 1;
2072         wpa_s->parent = wpa_s;
2073
2074         return wpa_s;
2075 }
2076
2077
2078 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
2079                                      struct wpa_interface *iface)
2080 {
2081         const char *ifname, *driver;
2082         struct wpa_driver_capa capa;
2083
2084         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
2085                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
2086                    iface->confname ? iface->confname : "N/A",
2087                    iface->driver ? iface->driver : "default",
2088                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
2089                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
2090
2091         if (iface->confname) {
2092 #ifdef CONFIG_BACKEND_FILE
2093                 wpa_s->confname = os_rel2abs_path(iface->confname);
2094                 if (wpa_s->confname == NULL) {
2095                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
2096                                    "for configuration file '%s'.",
2097                                    iface->confname);
2098                         return -1;
2099                 }
2100                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
2101                            iface->confname, wpa_s->confname);
2102 #else /* CONFIG_BACKEND_FILE */
2103                 wpa_s->confname = os_strdup(iface->confname);
2104 #endif /* CONFIG_BACKEND_FILE */
2105                 wpa_s->conf = wpa_config_read(wpa_s->confname);
2106                 if (wpa_s->conf == NULL) {
2107                         wpa_printf(MSG_ERROR, "Failed to read or parse "
2108                                    "configuration '%s'.", wpa_s->confname);
2109                         return -1;
2110                 }
2111
2112                 /*
2113                  * Override ctrl_interface and driver_param if set on command
2114                  * line.
2115                  */
2116                 if (iface->ctrl_interface) {
2117                         os_free(wpa_s->conf->ctrl_interface);
2118                         wpa_s->conf->ctrl_interface =
2119                                 os_strdup(iface->ctrl_interface);
2120                 }
2121
2122                 if (iface->driver_param) {
2123                         os_free(wpa_s->conf->driver_param);
2124                         wpa_s->conf->driver_param =
2125                                 os_strdup(iface->driver_param);
2126                 }
2127         } else
2128                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
2129                                                      iface->driver_param);
2130
2131         if (wpa_s->conf == NULL) {
2132                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
2133                 return -1;
2134         }
2135
2136         if (iface->ifname == NULL) {
2137                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
2138                 return -1;
2139         }
2140         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
2141                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
2142                            iface->ifname);
2143                 return -1;
2144         }
2145         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
2146
2147         if (iface->bridge_ifname) {
2148                 if (os_strlen(iface->bridge_ifname) >=
2149                     sizeof(wpa_s->bridge_ifname)) {
2150                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
2151                                    "name '%s'.", iface->bridge_ifname);
2152                         return -1;
2153                 }
2154                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
2155                            sizeof(wpa_s->bridge_ifname));
2156         }
2157
2158         /* RSNA Supplicant Key Management - INITIALIZE */
2159         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
2160         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
2161
2162         /* Initialize driver interface and register driver event handler before
2163          * L2 receive handler so that association events are processed before
2164          * EAPOL-Key packets if both become available for the same select()
2165          * call. */
2166         driver = iface->driver;
2167 next_driver:
2168         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
2169                 return -1;
2170
2171         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
2172         if (wpa_s->drv_priv == NULL) {
2173                 const char *pos;
2174                 pos = driver ? os_strchr(driver, ',') : NULL;
2175                 if (pos) {
2176                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
2177                                 "driver interface - try next driver wrapper");
2178                         driver = pos + 1;
2179                         goto next_driver;
2180                 }
2181                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
2182                         "interface");
2183                 return -1;
2184         }
2185         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
2186                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
2187                         "driver_param '%s'", wpa_s->conf->driver_param);
2188                 return -1;
2189         }
2190
2191         ifname = wpa_drv_get_ifname(wpa_s);
2192         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
2193                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
2194                         "interface name with '%s'", ifname);
2195                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2196         }
2197
2198         if (wpa_supplicant_init_wpa(wpa_s) < 0)
2199                 return -1;
2200
2201         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
2202                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
2203                           NULL);
2204         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
2205
2206         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
2207             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
2208                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
2209                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2210                         "dot11RSNAConfigPMKLifetime");
2211                 return -1;
2212         }
2213
2214         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
2215             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
2216                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
2217                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2218                         "dot11RSNAConfigPMKReauthThreshold");
2219                 return -1;
2220         }
2221
2222         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
2223             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
2224                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
2225                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2226                         "dot11RSNAConfigSATimeout");
2227                 return -1;
2228         }
2229
2230         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
2231                 wpa_s->drv_flags = capa.flags;
2232                 if (capa.flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
2233                         if (ieee80211_sta_init(wpa_s))
2234                                 return -1;
2235                 }
2236                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
2237                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
2238                 wpa_s->max_stations = capa.max_stations;
2239         }
2240         if (wpa_s->max_remain_on_chan == 0)
2241                 wpa_s->max_remain_on_chan = 1000;
2242
2243         if (wpa_supplicant_driver_init(wpa_s) < 0)
2244                 return -1;
2245
2246 #ifdef CONFIG_TDLS
2247         if (wpa_tdls_init(wpa_s->wpa))
2248                 return -1;
2249 #endif /* CONFIG_TDLS */
2250
2251         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
2252             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
2253                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
2254                 return -1;
2255         }
2256
2257         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2258
2259         if (wpas_wps_init(wpa_s))
2260                 return -1;
2261
2262         if (wpa_supplicant_init_eapol(wpa_s) < 0)
2263                 return -1;
2264         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2265
2266         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
2267         if (wpa_s->ctrl_iface == NULL) {
2268                 wpa_printf(MSG_ERROR,
2269                            "Failed to initialize control interface '%s'.\n"
2270                            "You may have another wpa_supplicant process "
2271                            "already running or the file was\n"
2272                            "left by an unclean termination of wpa_supplicant "
2273                            "in which case you will need\n"
2274                            "to manually remove this file before starting "
2275                            "wpa_supplicant again.\n",
2276                            wpa_s->conf->ctrl_interface);
2277                 return -1;
2278         }
2279
2280 #ifdef CONFIG_P2P
2281         if (wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
2282                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
2283                 return -1;
2284         }
2285 #endif /* CONFIG_P2P */
2286
2287         if (wpa_bss_init(wpa_s) < 0)
2288                 return -1;
2289
2290         return 0;
2291 }
2292
2293
2294 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
2295                                         int notify)
2296 {
2297         if (wpa_s->drv_priv) {
2298                 wpa_supplicant_deauthenticate(wpa_s,
2299                                               WLAN_REASON_DEAUTH_LEAVING);
2300
2301                 wpa_drv_set_countermeasures(wpa_s, 0);
2302                 wpa_clear_keys(wpa_s, NULL);
2303         }
2304
2305         wpa_supplicant_cleanup(wpa_s);
2306
2307         if (notify)
2308                 wpas_notify_iface_removed(wpa_s);
2309
2310         if (wpa_s->drv_priv)
2311                 wpa_drv_deinit(wpa_s);
2312 }
2313
2314
2315 /**
2316  * wpa_supplicant_add_iface - Add a new network interface
2317  * @global: Pointer to global data from wpa_supplicant_init()
2318  * @iface: Interface configuration options
2319  * Returns: Pointer to the created interface or %NULL on failure
2320  *
2321  * This function is used to add new network interfaces for %wpa_supplicant.
2322  * This can be called before wpa_supplicant_run() to add interfaces before the
2323  * main event loop has been started. In addition, new interfaces can be added
2324  * dynamically while %wpa_supplicant is already running. This could happen,
2325  * e.g., when a hotplug network adapter is inserted.
2326  */
2327 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
2328                                                  struct wpa_interface *iface)
2329 {
2330         struct wpa_supplicant *wpa_s;
2331         struct wpa_interface t_iface;
2332         struct wpa_ssid *ssid;
2333
2334         if (global == NULL || iface == NULL)
2335                 return NULL;
2336
2337         wpa_s = wpa_supplicant_alloc();
2338         if (wpa_s == NULL)
2339                 return NULL;
2340
2341         wpa_s->global = global;
2342
2343         t_iface = *iface;
2344         if (global->params.override_driver) {
2345                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
2346                            "('%s' -> '%s')",
2347                            iface->driver, global->params.override_driver);
2348                 t_iface.driver = global->params.override_driver;
2349         }
2350         if (global->params.override_ctrl_interface) {
2351                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
2352                            "ctrl_interface ('%s' -> '%s')",
2353                            iface->ctrl_interface,
2354                            global->params.override_ctrl_interface);
2355                 t_iface.ctrl_interface =
2356                         global->params.override_ctrl_interface;
2357         }
2358         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
2359                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
2360                            iface->ifname);
2361                 wpa_supplicant_deinit_iface(wpa_s, 0);
2362                 os_free(wpa_s);
2363                 return NULL;
2364         }
2365
2366         /* Notify the control interfaces about new iface */
2367         if (wpas_notify_iface_added(wpa_s)) {
2368                 wpa_supplicant_deinit_iface(wpa_s, 1);
2369                 os_free(wpa_s);
2370                 return NULL;
2371         }
2372
2373         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2374                 wpas_notify_network_added(wpa_s, ssid);
2375
2376         wpa_s->next = global->ifaces;
2377         global->ifaces = wpa_s;
2378
2379         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
2380
2381         return wpa_s;
2382 }
2383
2384
2385 /**
2386  * wpa_supplicant_remove_iface - Remove a network interface
2387  * @global: Pointer to global data from wpa_supplicant_init()
2388  * @wpa_s: Pointer to the network interface to be removed
2389  * Returns: 0 if interface was removed, -1 if interface was not found
2390  *
2391  * This function can be used to dynamically remove network interfaces from
2392  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
2393  * addition, this function is used to remove all remaining interfaces when
2394  * %wpa_supplicant is terminated.
2395  */
2396 int wpa_supplicant_remove_iface(struct wpa_global *global,
2397                                 struct wpa_supplicant *wpa_s)
2398 {
2399         struct wpa_supplicant *prev;
2400
2401         /* Remove interface from the global list of interfaces */
2402         prev = global->ifaces;
2403         if (prev == wpa_s) {
2404                 global->ifaces = wpa_s->next;
2405         } else {
2406                 while (prev && prev->next != wpa_s)
2407                         prev = prev->next;
2408                 if (prev == NULL)
2409                         return -1;
2410                 prev->next = wpa_s->next;
2411         }
2412
2413         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
2414
2415         if (global->p2p_group_formation == wpa_s)
2416                 global->p2p_group_formation = NULL;
2417         wpa_supplicant_deinit_iface(wpa_s, 1);
2418         os_free(wpa_s);
2419
2420         return 0;
2421 }
2422
2423
2424 /**
2425  * wpa_supplicant_get_eap_mode - Get the current EAP mode
2426  * @wpa_s: Pointer to the network interface
2427  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
2428  */
2429 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
2430 {
2431         const char *eapol_method;
2432
2433         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
2434             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2435                 return "NO-EAP";
2436         }
2437
2438         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
2439         if (eapol_method == NULL)
2440                 return "UNKNOWN-EAP";
2441
2442         return eapol_method;
2443 }
2444
2445
2446 /**
2447  * wpa_supplicant_get_iface - Get a new network interface
2448  * @global: Pointer to global data from wpa_supplicant_init()
2449  * @ifname: Interface name
2450  * Returns: Pointer to the interface or %NULL if not found
2451  */
2452 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
2453                                                  const char *ifname)
2454 {
2455         struct wpa_supplicant *wpa_s;
2456
2457         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
2458                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
2459                         return wpa_s;
2460         }
2461         return NULL;
2462 }
2463
2464
2465 #ifndef CONFIG_NO_WPA_MSG
2466 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
2467 {
2468         struct wpa_supplicant *wpa_s = ctx;
2469         if (wpa_s == NULL)
2470                 return NULL;
2471         return wpa_s->ifname;
2472 }
2473 #endif /* CONFIG_NO_WPA_MSG */
2474
2475
2476 /**
2477  * wpa_supplicant_init - Initialize %wpa_supplicant
2478  * @params: Parameters for %wpa_supplicant
2479  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
2480  *
2481  * This function is used to initialize %wpa_supplicant. After successful
2482  * initialization, the returned data pointer can be used to add and remove
2483  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
2484  */
2485 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
2486 {
2487         struct wpa_global *global;
2488         int ret, i;
2489
2490         if (params == NULL)
2491                 return NULL;
2492
2493 #ifndef CONFIG_NO_WPA_MSG
2494         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
2495 #endif /* CONFIG_NO_WPA_MSG */
2496
2497         wpa_debug_open_file(params->wpa_debug_file_path);
2498         if (params->wpa_debug_syslog)
2499                 wpa_debug_open_syslog();
2500
2501         ret = eap_register_methods();
2502         if (ret) {
2503                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
2504                 if (ret == -2)
2505                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
2506                                    "the same EAP type.");
2507                 return NULL;
2508         }
2509
2510         global = os_zalloc(sizeof(*global));
2511         if (global == NULL)
2512                 return NULL;
2513         dl_list_init(&global->p2p_srv_bonjour);
2514         dl_list_init(&global->p2p_srv_upnp);
2515         global->params.daemonize = params->daemonize;
2516         global->params.wait_for_monitor = params->wait_for_monitor;
2517         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
2518         if (params->pid_file)
2519                 global->params.pid_file = os_strdup(params->pid_file);
2520         if (params->ctrl_interface)
2521                 global->params.ctrl_interface =
2522                         os_strdup(params->ctrl_interface);
2523         if (params->override_driver)
2524                 global->params.override_driver =
2525                         os_strdup(params->override_driver);
2526         if (params->override_ctrl_interface)
2527                 global->params.override_ctrl_interface =
2528                         os_strdup(params->override_ctrl_interface);
2529         wpa_debug_level = global->params.wpa_debug_level =
2530                 params->wpa_debug_level;
2531         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
2532                 params->wpa_debug_show_keys;
2533         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
2534                 params->wpa_debug_timestamp;
2535
2536         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
2537
2538         if (eloop_init()) {
2539                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
2540                 wpa_supplicant_deinit(global);
2541                 return NULL;
2542         }
2543
2544         random_init();
2545
2546         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
2547         if (global->ctrl_iface == NULL) {
2548                 wpa_supplicant_deinit(global);
2549                 return NULL;
2550         }
2551
2552         if (wpas_notify_supplicant_initialized(global)) {
2553                 wpa_supplicant_deinit(global);
2554                 return NULL;
2555         }
2556
2557         for (i = 0; wpa_drivers[i]; i++)
2558                 global->drv_count++;
2559         if (global->drv_count == 0) {
2560                 wpa_printf(MSG_ERROR, "No drivers enabled");
2561                 wpa_supplicant_deinit(global);
2562                 return NULL;
2563         }
2564         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
2565         if (global->drv_priv == NULL) {
2566                 wpa_supplicant_deinit(global);
2567                 return NULL;
2568         }
2569         for (i = 0; wpa_drivers[i]; i++) {
2570                 if (!wpa_drivers[i]->global_init)
2571                         continue;
2572                 global->drv_priv[i] = wpa_drivers[i]->global_init();
2573                 if (global->drv_priv[i] == NULL) {
2574                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
2575                                    "'%s'", wpa_drivers[i]->name);
2576                         wpa_supplicant_deinit(global);
2577                         return NULL;
2578                 }
2579         }
2580
2581         return global;
2582 }
2583
2584
2585 /**
2586  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
2587  * @global: Pointer to global data from wpa_supplicant_init()
2588  * Returns: 0 after successful event loop run, -1 on failure
2589  *
2590  * This function starts the main event loop and continues running as long as
2591  * there are any remaining events. In most cases, this function is running as
2592  * long as the %wpa_supplicant process in still in use.
2593  */
2594 int wpa_supplicant_run(struct wpa_global *global)
2595 {
2596         struct wpa_supplicant *wpa_s;
2597
2598         if (global->params.daemonize &&
2599             wpa_supplicant_daemon(global->params.pid_file))
2600                 return -1;
2601
2602         if (global->params.wait_for_monitor) {
2603                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
2604                         if (wpa_s->ctrl_iface)
2605                                 wpa_supplicant_ctrl_iface_wait(
2606                                         wpa_s->ctrl_iface);
2607         }
2608
2609         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
2610         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
2611
2612         eloop_run();
2613
2614         return 0;
2615 }
2616
2617
2618 /**
2619  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
2620  * @global: Pointer to global data from wpa_supplicant_init()
2621  *
2622  * This function is called to deinitialize %wpa_supplicant and to free all
2623  * allocated resources. Remaining network interfaces will also be removed.
2624  */
2625 void wpa_supplicant_deinit(struct wpa_global *global)
2626 {
2627         int i;
2628
2629         if (global == NULL)
2630                 return;
2631
2632 #ifdef CONFIG_P2P
2633         wpas_p2p_deinit_global(global);
2634 #endif /* CONFIG_P2P */
2635
2636         while (global->ifaces)
2637                 wpa_supplicant_remove_iface(global, global->ifaces);
2638
2639         if (global->ctrl_iface)
2640                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
2641
2642         wpas_notify_supplicant_deinitialized(global);
2643
2644         eap_peer_unregister_methods();
2645 #ifdef CONFIG_AP
2646         eap_server_unregister_methods();
2647 #endif /* CONFIG_AP */
2648
2649         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
2650                 if (!global->drv_priv[i])
2651                         continue;
2652                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
2653         }
2654         os_free(global->drv_priv);
2655
2656         random_deinit();
2657
2658         eloop_destroy();
2659
2660         if (global->params.pid_file) {
2661                 os_daemonize_terminate(global->params.pid_file);
2662                 os_free(global->params.pid_file);
2663         }
2664         os_free(global->params.ctrl_interface);
2665         os_free(global->params.override_driver);
2666         os_free(global->params.override_ctrl_interface);
2667
2668         os_free(global);
2669         wpa_debug_close_syslog();
2670         wpa_debug_close_file();
2671 }
2672
2673
2674 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
2675 {
2676 #ifdef CONFIG_WPS
2677         wpas_wps_update_config(wpa_s);
2678 #endif /* CONFIG_WPS */
2679
2680 #ifdef CONFIG_P2P
2681         wpas_p2p_update_config(wpa_s);
2682 #endif /* CONFIG_P2P */
2683
2684         wpa_s->conf->changed_parameters = 0;
2685 }
2686
2687
2688 void ieee80211_sta_free_hw_features(struct hostapd_hw_modes *hw_features,
2689                                     size_t num_hw_features)
2690 {
2691         size_t i;
2692
2693         if (hw_features == NULL)
2694                 return;
2695
2696         for (i = 0; i < num_hw_features; i++) {
2697                 os_free(hw_features[i].channels);
2698                 os_free(hw_features[i].rates);
2699         }
2700
2701         os_free(hw_features);
2702 }
2703
2704
2705 static void add_freq(int *freqs, int *num_freqs, int freq)
2706 {
2707         int i;
2708
2709         for (i = 0; i < *num_freqs; i++) {
2710                 if (freqs[i] == freq)
2711                         return;
2712         }
2713
2714         freqs[*num_freqs] = freq;
2715         (*num_freqs)++;
2716 }
2717
2718
2719 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
2720 {
2721         struct wpa_bss *bss, *cbss;
2722         const int max_freqs = 10;
2723         int *freqs;
2724         int num_freqs = 0;
2725
2726         freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
2727         if (freqs == NULL)
2728                 return NULL;
2729
2730         cbss = wpa_s->current_bss;
2731
2732         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
2733                 if (bss == cbss)
2734                         continue;
2735                 if (bss->ssid_len == cbss->ssid_len &&
2736                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
2737                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
2738                         add_freq(freqs, &num_freqs, bss->freq);
2739                         if (num_freqs == max_freqs)
2740                                 break;
2741                 }
2742         }
2743
2744         if (num_freqs == 0) {
2745                 os_free(freqs);
2746                 freqs = NULL;
2747         }
2748
2749         return freqs;
2750 }
2751
2752
2753 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
2754 {
2755         int timeout;
2756         int count;
2757         int *freqs = NULL;
2758
2759         /*
2760          * Add the failed BSSID into the blacklist and speed up next scan
2761          * attempt if there could be other APs that could accept association.
2762          * The current blacklist count indicates how many times we have tried
2763          * connecting to this AP and multiple attempts mean that other APs are
2764          * either not available or has already been tried, so that we can start
2765          * increasing the delay here to avoid constant scanning.
2766          */
2767         count = wpa_blacklist_add(wpa_s, bssid);
2768         if (count == 1 && wpa_s->current_bss) {
2769                 /*
2770                  * This BSS was not in the blacklist before. If there is
2771                  * another BSS available for the same ESS, we should try that
2772                  * next. Otherwise, we may as well try this one once more
2773                  * before allowing other, likely worse, ESSes to be considered.
2774                  */
2775                 freqs = get_bss_freqs_in_ess(wpa_s);
2776                 if (freqs) {
2777                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
2778                                 "has been seen; try it next");
2779                         wpa_blacklist_add(wpa_s, bssid);
2780                         /*
2781                          * On the next scan, go through only the known channels
2782                          * used in this ESS based on previous scans to speed up
2783                          * common load balancing use case.
2784                          */
2785                         os_free(wpa_s->next_scan_freqs);
2786                         wpa_s->next_scan_freqs = freqs;
2787                 }
2788         }
2789
2790         switch (count) {
2791         case 1:
2792                 timeout = 100;
2793                 break;
2794         case 2:
2795                 timeout = 500;
2796                 break;
2797         case 3:
2798                 timeout = 1000;
2799                 break;
2800         default:
2801                 timeout = 5000;
2802         }
2803
2804         /*
2805          * TODO: if more than one possible AP is available in scan results,
2806          * could try the other ones before requesting a new scan.
2807          */
2808         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
2809                                 1000 * (timeout % 1000));
2810 }