wpa_supplicant/wpa_supplicant.c

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