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_INTERFACE_DISABLED:
 493                 return "INTERFACE_DISABLED";
 494         case WPA_SCANNING:
 495                 return "SCANNING";
 496         case WPA_AUTHENTICATING:
 497                 return "AUTHENTICATING";
 498         case WPA_ASSOCIATING:
 499                 return "ASSOCIATING";
 500         case WPA_ASSOCIATED:
 501                 return "ASSOCIATED";
 502         case WPA_4WAY_HANDSHAKE:
 503                 return "4WAY_HANDSHAKE";
 504         case WPA_GROUP_HANDSHAKE:
 505                 return "GROUP_HANDSHAKE";
 506         case WPA_COMPLETED:
 507                 return "COMPLETED";
 508         default:
 509                 return "UNKNOWN";
 510         }
 511 }
 512
 513
 514 /**
 515  * wpa_supplicant_set_state - Set current connection state
 516  * @wpa_s: Pointer to wpa_supplicant data
 517  * @state: The new connection state
 518  *
 519  * This function is called whenever the connection state changes, e.g.,
 520  * association is completed for WPA/WPA2 4-Way Handshake is started.
 521  */
 522 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
 523                               enum wpa_states state)
 524 {
 525         enum wpa_states old_state = wpa_s->wpa_state;
 526
 527         wpa_printf(MSG_DEBUG, "State: %s -> %s",
 528                    wpa_supplicant_state_txt(wpa_s->wpa_state),
 529                    wpa_supplicant_state_txt(state));
 530
 531         if (state != WPA_SCANNING)
 532                 wpa_supplicant_notify_scanning(wpa_s, 0);
 533
 534         if (state == WPA_COMPLETED && wpa_s->new_connection) {
 535 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 536                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 537                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
 538                         MACSTR " completed %s [id=%d id_str=%s]",
 539                         MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ?
 540                         "(reauth)" : "(auth)",
 541                         ssid ? ssid->id : -1,
 542                         ssid && ssid->id_str ? ssid->id_str : "");
 543 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 544                 wpa_s->new_connection = 0;
 545                 wpa_s->reassociated_connection = 1;
 546                 wpa_drv_set_operstate(wpa_s, 1);
 547                 wpa_s->after_wps = 0;
 548         } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
 549                    state == WPA_ASSOCIATED) {
 550                 wpa_s->new_connection = 1;
 551                 wpa_drv_set_operstate(wpa_s, 0);
 552         }
 553         wpa_s->wpa_state = state;
 554
 555         if (wpa_s->wpa_state != old_state)
 556                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 557 }
 558
 559
 560 void wpa_supplicant_terminate_proc(struct wpa_global *global)
 561 {
 562         int pending = 0;
 563 #ifdef CONFIG_WPS
 564         struct wpa_supplicant *wpa_s = global->ifaces;
 565         while (wpa_s) {
 566                 if (wpas_wps_terminate_pending(wpa_s) == 1)
 567                         pending = 1;
 568                 wpa_s = wpa_s->next;
 569         }
 570 #endif /* CONFIG_WPS */
 571         if (pending)
 572                 return;
 573         eloop_terminate();
 574 }
 575
 576
 577 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
 578 {
 579         struct wpa_global *global = signal_ctx;
 580         struct wpa_supplicant *wpa_s;
 581         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 582                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d "
 583                         "received", sig);
 584         }
 585         wpa_supplicant_terminate_proc(global);
 586 }
 587
 588
 589 static void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
 590 {
 591         enum wpa_states old_state = wpa_s->wpa_state;
 592
 593         wpa_s->pairwise_cipher = 0;
 594         wpa_s->group_cipher = 0;
 595         wpa_s->mgmt_group_cipher = 0;
 596         wpa_s->key_mgmt = 0;
 597         if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
 598                 wpa_s->wpa_state = WPA_DISCONNECTED;
 599
 600         if (wpa_s->wpa_state != old_state)
 601                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 602 }
 603
 604
 605 /**
 606  * wpa_supplicant_reload_configuration - Reload configuration data
 607  * @wpa_s: Pointer to wpa_supplicant data
 608  * Returns: 0 on success or -1 if configuration parsing failed
 609  *
 610  * This function can be used to request that the configuration data is reloaded
 611  * (e.g., after configuration file change). This function is reloading
 612  * configuration only for one interface, so this may need to be called multiple
 613  * times if %wpa_supplicant is controlling multiple interfaces and all
 614  * interfaces need reconfiguration.
 615  */
 616 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
 617 {
 618         struct wpa_config *conf;
 619         struct wpa_ssid *old_ssid;
 620         int reconf_ctrl;
 621         int old_ap_scan;
 622
 623         if (wpa_s->confname == NULL)
 624                 return -1;
 625         conf = wpa_config_read(wpa_s->confname);
 626         if (conf == NULL) {
 627                 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
 628                         "file '%s' - exiting", wpa_s->confname);
 629                 return -1;
 630         }
 631         conf->changed_parameters = (unsigned int) -1;
 632
 633         reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
 634                 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
 635                     os_strcmp(conf->ctrl_interface,
 636                               wpa_s->conf->ctrl_interface) != 0);
 637
 638         if (reconf_ctrl && wpa_s->ctrl_iface) {
 639                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 640                 wpa_s->ctrl_iface = NULL;
 641         }
 642
 643         eapol_sm_invalidate_cached_session(wpa_s->eapol);
 644         old_ssid = wpa_s->current_ssid;
 645         wpa_s->current_ssid = NULL;
 646         if (old_ssid != wpa_s->current_ssid)
 647                 wpas_notify_network_changed(wpa_s);
 648
 649         /*
 650          * TODO: should notify EAPOL SM about changes in opensc_engine_path,
 651          * pkcs11_engine_path, pkcs11_module_path.
 652          */
 653         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 654                 /*
 655                  * Clear forced success to clear EAP state for next
 656                  * authentication.
 657                  */
 658                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 659         }
 660         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
 661         wpa_sm_set_config(wpa_s->wpa, NULL);
 662         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
 663         rsn_preauth_deinit(wpa_s->wpa);
 664
 665         old_ap_scan = wpa_s->conf->ap_scan;
 666         wpa_config_free(wpa_s->conf);
 667         wpa_s->conf = conf;
 668         if (old_ap_scan != wpa_s->conf->ap_scan)
 669                 wpas_notify_ap_scan_changed(wpa_s);
 670
 671         if (reconf_ctrl)
 672                 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
 673
 674         wpa_supplicant_update_config(wpa_s);
 675
 676         wpa_supplicant_clear_status(wpa_s);
 677         wpa_s->reassociate = 1;
 678         wpa_supplicant_req_scan(wpa_s, 0, 0);
 679         wpa_msg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
 680         return 0;
 681 }
 682
 683
 684 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
 685 {
 686         struct wpa_global *global = signal_ctx;
 687         struct wpa_supplicant *wpa_s;
 688         wpa_printf(MSG_DEBUG, "Signal %d received - reconfiguring", sig);
 689         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 690                 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
 691                         wpa_supplicant_terminate_proc(global);
 692                 }
 693         }
 694 }
 695
 696
 697 enum wpa_cipher cipher_suite2driver(int cipher)
 698 {
 699         switch (cipher) {
 700         case WPA_CIPHER_NONE:
 701                 return CIPHER_NONE;
 702         case WPA_CIPHER_WEP40:
 703                 return CIPHER_WEP40;
 704         case WPA_CIPHER_WEP104:
 705                 return CIPHER_WEP104;
 706         case WPA_CIPHER_CCMP:
 707                 return CIPHER_CCMP;
 708         case WPA_CIPHER_TKIP:
 709         default:
 710                 return CIPHER_TKIP;
 711         }
 712 }
 713
 714
 715 enum wpa_key_mgmt key_mgmt2driver(int key_mgmt)
 716 {
 717         switch (key_mgmt) {
 718         case WPA_KEY_MGMT_NONE:
 719                 return KEY_MGMT_NONE;
 720         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
 721                 return KEY_MGMT_802_1X_NO_WPA;
 722         case WPA_KEY_MGMT_IEEE8021X:
 723                 return KEY_MGMT_802_1X;
 724         case WPA_KEY_MGMT_WPA_NONE:
 725                 return KEY_MGMT_WPA_NONE;
 726         case WPA_KEY_MGMT_FT_IEEE8021X:
 727                 return KEY_MGMT_FT_802_1X;
 728         case WPA_KEY_MGMT_FT_PSK:
 729                 return KEY_MGMT_FT_PSK;
 730         case WPA_KEY_MGMT_IEEE8021X_SHA256:
 731                 return KEY_MGMT_802_1X_SHA256;
 732         case WPA_KEY_MGMT_PSK_SHA256:
 733                 return KEY_MGMT_PSK_SHA256;
 734         case WPA_KEY_MGMT_WPS:
 735                 return KEY_MGMT_WPS;
 736         case WPA_KEY_MGMT_PSK:
 737         default:
 738                 return KEY_MGMT_PSK;
 739         }
 740 }
 741
 742
 743 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
 744                                          struct wpa_ssid *ssid,
 745                                          struct wpa_ie_data *ie)
 746 {
 747         int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
 748         if (ret) {
 749                 if (ret == -2) {
 750                         wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
 751                                 "from association info");
 752                 }
 753                 return -1;
 754         }
 755
 756         wpa_printf(MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set cipher "
 757                    "suites");
 758         if (!(ie->group_cipher & ssid->group_cipher)) {
 759                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
 760                         "cipher 0x%x (mask 0x%x) - reject",
 761                         ie->group_cipher, ssid->group_cipher);
 762                 return -1;
 763         }
 764         if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
 765                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
 766                         "cipher 0x%x (mask 0x%x) - reject",
 767                         ie->pairwise_cipher, ssid->pairwise_cipher);
 768                 return -1;
 769         }
 770         if (!(ie->key_mgmt & ssid->key_mgmt)) {
 771                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
 772                         "management 0x%x (mask 0x%x) - reject",
 773                         ie->key_mgmt, ssid->key_mgmt);
 774                 return -1;
 775         }
 776
 777 #ifdef CONFIG_IEEE80211W
 778         if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
 779             ssid->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED) {
 780                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
 781                         "that does not support management frame protection - "
 782                         "reject");
 783                 return -1;
 784         }
 785 #endif /* CONFIG_IEEE80211W */
 786
 787         return 0;
 788 }
 789
 790
 791 /**
 792  * wpa_supplicant_set_suites - Set authentication and encryption parameters
 793  * @wpa_s: Pointer to wpa_supplicant data
 794  * @bss: Scan results for the selected BSS, or %NULL if not available
 795  * @ssid: Configuration data for the selected network
 796  * @wpa_ie: Buffer for the WPA/RSN IE
 797  * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
 798  * used buffer length in case the functions returns success.
 799  * Returns: 0 on success or -1 on failure
 800  *
 801  * This function is used to configure authentication and encryption parameters
 802  * based on the network configuration and scan result for the selected BSS (if
 803  * available).
 804  */
 805 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
 806                               struct wpa_bss *bss, struct wpa_ssid *ssid,
 807                               u8 *wpa_ie, size_t *wpa_ie_len)
 808 {
 809         struct wpa_ie_data ie;
 810         int sel, proto;
 811         const u8 *bss_wpa, *bss_rsn;
 812
 813         if (bss) {
 814                 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
 815                 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
 816         } else
 817                 bss_wpa = bss_rsn = NULL;
 818
 819         if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
 820             wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[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, "RSN: using IEEE 802.11i/D9.0");
 825                 proto = WPA_PROTO_RSN;
 826         } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
 827                    wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
 828                    (ie.group_cipher & ssid->group_cipher) &&
 829                    (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 830                    (ie.key_mgmt & ssid->key_mgmt)) {
 831                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
 832                 proto = WPA_PROTO_WPA;
 833         } else if (bss) {
 834                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
 835                 return -1;
 836         } else {
 837                 if (ssid->proto & WPA_PROTO_RSN)
 838                         proto = WPA_PROTO_RSN;
 839                 else
 840                         proto = WPA_PROTO_WPA;
 841                 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
 842                         os_memset(&ie, 0, sizeof(ie));
 843                         ie.group_cipher = ssid->group_cipher;
 844                         ie.pairwise_cipher = ssid->pairwise_cipher;
 845                         ie.key_mgmt = ssid->key_mgmt;
 846 #ifdef CONFIG_IEEE80211W
 847                         ie.mgmt_group_cipher =
 848                                 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
 849                                 WPA_CIPHER_AES_128_CMAC : 0;
 850 #endif /* CONFIG_IEEE80211W */
 851                         wpa_printf(MSG_DEBUG, "WPA: Set cipher suites based "
 852                                    "on configuration");
 853                 } else
 854                         proto = ie.proto;
 855         }
 856
 857         wpa_printf(MSG_DEBUG, "WPA: Selected cipher suites: group %d "
 858                    "pairwise %d key_mgmt %d proto %d",
 859                    ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
 860 #ifdef CONFIG_IEEE80211W
 861         if (ssid->ieee80211w) {
 862                 wpa_printf(MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
 863                            ie.mgmt_group_cipher);
 864         }
 865 #endif /* CONFIG_IEEE80211W */
 866
 867         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
 868         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
 869                          !!(ssid->proto & WPA_PROTO_RSN));
 870
 871         if (bss || !wpa_s->ap_ies_from_associnfo) {
 872                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
 873                                          bss_wpa ? 2 + bss_wpa[1] : 0) ||
 874                     wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
 875                                          bss_rsn ? 2 + bss_rsn[1] : 0))
 876                         return -1;
 877         }
 878
 879         sel = ie.group_cipher & ssid->group_cipher;
 880         if (sel & WPA_CIPHER_CCMP) {
 881                 wpa_s->group_cipher = WPA_CIPHER_CCMP;
 882                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP");
 883         } else if (sel & WPA_CIPHER_TKIP) {
 884                 wpa_s->group_cipher = WPA_CIPHER_TKIP;
 885                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP");
 886         } else if (sel & WPA_CIPHER_WEP104) {
 887                 wpa_s->group_cipher = WPA_CIPHER_WEP104;
 888                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104");
 889         } else if (sel & WPA_CIPHER_WEP40) {
 890                 wpa_s->group_cipher = WPA_CIPHER_WEP40;
 891                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40");
 892         } else {
 893                 wpa_printf(MSG_WARNING, "WPA: Failed to select group cipher.");
 894                 return -1;
 895         }
 896
 897         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
 898         if (sel & WPA_CIPHER_CCMP) {
 899                 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
 900                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP");
 901         } else if (sel & WPA_CIPHER_TKIP) {
 902                 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
 903                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP");
 904         } else if (sel & WPA_CIPHER_NONE) {
 905                 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 906                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE");
 907         } else {
 908                 wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
 909                            "cipher.");
 910                 return -1;
 911         }
 912
 913         sel = ie.key_mgmt & ssid->key_mgmt;
 914         if (0) {
 915 #ifdef CONFIG_IEEE80211R
 916         } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
 917                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
 918                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
 919         } else if (sel & WPA_KEY_MGMT_FT_PSK) {
 920                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
 921                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
 922 #endif /* CONFIG_IEEE80211R */
 923 #ifdef CONFIG_IEEE80211W
 924         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
 925                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
 926                 wpa_msg(wpa_s, MSG_DEBUG,
 927                         "WPA: using KEY_MGMT 802.1X with SHA256");
 928         } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
 929                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
 930                 wpa_msg(wpa_s, MSG_DEBUG,
 931                         "WPA: using KEY_MGMT PSK with SHA256");
 932 #endif /* CONFIG_IEEE80211W */
 933         } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
 934                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
 935                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
 936         } else if (sel & WPA_KEY_MGMT_PSK) {
 937                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
 938                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
 939         } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
 940                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
 941                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
 942         } else {
 943                 wpa_printf(MSG_WARNING, "WPA: Failed to select authenticated "
 944                            "key management type.");
 945                 return -1;
 946         }
 947
 948         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 949         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 950                          wpa_s->pairwise_cipher);
 951         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 952
 953 #ifdef CONFIG_IEEE80211W
 954         sel = ie.mgmt_group_cipher;
 955         if (ssid->ieee80211w == NO_MGMT_FRAME_PROTECTION ||
 956             !(ie.capabilities & WPA_CAPABILITY_MFPC))
 957                 sel = 0;
 958         if (sel & WPA_CIPHER_AES_128_CMAC) {
 959                 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
 960                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
 961                         "AES-128-CMAC");
 962         } else {
 963                 wpa_s->mgmt_group_cipher = 0;
 964                 wpa_msg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
 965         }
 966         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 967                          wpa_s->mgmt_group_cipher);
 968         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, ssid->ieee80211w);
 969 #endif /* CONFIG_IEEE80211W */
 970
 971         if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
 972                 wpa_printf(MSG_WARNING, "WPA: Failed to generate WPA IE.");
 973                 return -1;
 974         }
 975
 976         if (ssid->key_mgmt &
 977             (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_FT_PSK | WPA_KEY_MGMT_PSK_SHA256))
 978                 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
 979         else
 980                 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
 981
 982         return 0;
 983 }
 984
 985
 986 /**
 987  * wpa_supplicant_associate - Request association
 988  * @wpa_s: Pointer to wpa_supplicant data
 989  * @bss: Scan results for the selected BSS, or %NULL if not available
 990  * @ssid: Configuration data for the selected network
 991  *
 992  * This function is used to request %wpa_supplicant to associate with a BSS.
 993  */
 994 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
 995                               struct wpa_bss *bss, struct wpa_ssid *ssid)
 996 {
 997         u8 wpa_ie[80];
 998         size_t wpa_ie_len;
 999         int use_crypt, ret, i, bssid_changed;
1000         int algs = WPA_AUTH_ALG_OPEN;
1001         enum wpa_cipher cipher_pairwise, cipher_group;
1002         struct wpa_driver_associate_params params;
1003         int wep_keys_set = 0;
1004         struct wpa_driver_capa capa;
1005         int assoc_failed = 0;
1006         struct wpa_ssid *old_ssid;
1007
1008         if (ssid->mode == WPAS_MODE_AP) {
1009 #ifdef CONFIG_AP
1010                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1011                         wpa_printf(MSG_INFO, "Driver does not support AP "
1012                                    "mode");
1013                         return;
1014                 }
1015                 wpa_supplicant_create_ap(wpa_s, ssid);
1016                 wpa_s->current_bss = bss;
1017 #else /* CONFIG_AP */
1018                 wpa_printf(MSG_ERROR, "AP mode support not included in the "
1019                            "build");
1020 #endif /* CONFIG_AP */
1021                 return;
1022         }
1023
1024         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1025             ssid->mode == IEEE80211_MODE_INFRA) {
1026                 sme_authenticate(wpa_s, bss, ssid);
1027                 return;
1028         }
1029
1030         os_memset(&params, 0, sizeof(params));
1031         wpa_s->reassociate = 0;
1032         if (bss) {
1033 #ifdef CONFIG_IEEE80211R
1034                 const u8 *ie, *md = NULL;
1035 #endif /* CONFIG_IEEE80211R */
1036                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1037                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
1038                         wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
1039                 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1040                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1041                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1042                 if (bssid_changed)
1043                         wpas_notify_bssid_changed(wpa_s);
1044 #ifdef CONFIG_IEEE80211R
1045                 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
1046                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1047                         md = ie + 2;
1048                 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1049                 if (md) {
1050                         /* Prepare for the next transition */
1051                         wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1052                 }
1053 #endif /* CONFIG_IEEE80211R */
1054 #ifdef CONFIG_WPS
1055         } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1056                    wpa_s->conf->ap_scan == 2 &&
1057                    (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1058                 /* Use ap_scan==1 style network selection to find the network
1059                  */
1060                 wpa_s->scan_req = 2;
1061                 wpa_s->reassociate = 1;
1062                 wpa_supplicant_req_scan(wpa_s, 0, 0);
1063                 return;
1064 #endif /* CONFIG_WPS */
1065         } else {
1066                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1067                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1068                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1069         }
1070         wpa_supplicant_cancel_scan(wpa_s);
1071
1072         /* Starting new association, so clear the possibly used WPA IE from the
1073          * previous association. */
1074         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1075
1076 #ifdef IEEE8021X_EAPOL
1077         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1078                 if (ssid->leap) {
1079                         if (ssid->non_leap == 0)
1080                                 algs = WPA_AUTH_ALG_LEAP;
1081                         else
1082                                 algs |= WPA_AUTH_ALG_LEAP;
1083                 }
1084         }
1085 #endif /* IEEE8021X_EAPOL */
1086         wpa_printf(MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1087         if (ssid->auth_alg) {
1088                 algs = ssid->auth_alg;
1089                 wpa_printf(MSG_DEBUG, "Overriding auth_alg selection: 0x%x",
1090                            algs);
1091         }
1092
1093         if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1094                     wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
1095             (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |
1096                                WPA_KEY_MGMT_FT_IEEE8021X |
1097                                WPA_KEY_MGMT_FT_PSK |
1098                                WPA_KEY_MGMT_IEEE8021X_SHA256 |
1099                                WPA_KEY_MGMT_PSK_SHA256))) {
1100                 int try_opportunistic;
1101                 try_opportunistic = ssid->proactive_key_caching &&
1102                         (ssid->proto & WPA_PROTO_RSN);
1103                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1104                                             wpa_s->current_ssid,
1105                                             try_opportunistic) == 0)
1106                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1107                 wpa_ie_len = sizeof(wpa_ie);
1108                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1109                                               wpa_ie, &wpa_ie_len)) {
1110                         wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
1111                                    "management and encryption suites");
1112                         return;
1113                 }
1114         } else if (ssid->key_mgmt &
1115                    (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X |
1116                     WPA_KEY_MGMT_WPA_NONE | WPA_KEY_MGMT_FT_PSK |
1117                     WPA_KEY_MGMT_FT_IEEE8021X | WPA_KEY_MGMT_PSK_SHA256 |
1118                     WPA_KEY_MGMT_IEEE8021X_SHA256)) {
1119                 wpa_ie_len = sizeof(wpa_ie);
1120                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1121                                               wpa_ie, &wpa_ie_len)) {
1122                         wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
1123                                    "management and encryption suites (no scan "
1124                                    "results)");
1125                         return;
1126                 }
1127 #ifdef CONFIG_WPS
1128         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
1129                 struct wpabuf *wps_ie;
1130                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
1131                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1132                         wpa_ie_len = wpabuf_len(wps_ie);
1133                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
1134                 } else
1135                         wpa_ie_len = 0;
1136                 wpabuf_free(wps_ie);
1137                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1138                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1139                         params.wps = WPS_MODE_PRIVACY;
1140                 else
1141                         params.wps = WPS_MODE_OPEN;
1142 #endif /* CONFIG_WPS */
1143         } else {
1144                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1145                 wpa_ie_len = 0;
1146         }
1147
1148         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1149         use_crypt = 1;
1150         cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher);
1151         cipher_group = cipher_suite2driver(wpa_s->group_cipher);
1152         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1153             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1154                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1155                         use_crypt = 0;
1156                 if (wpa_set_wep_keys(wpa_s, ssid)) {
1157                         use_crypt = 1;
1158                         wep_keys_set = 1;
1159                 }
1160         }
1161         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1162                 use_crypt = 0;
1163
1164 #ifdef IEEE8021X_EAPOL
1165         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1166                 if ((ssid->eapol_flags &
1167                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1168                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1169                     !wep_keys_set) {
1170                         use_crypt = 0;
1171                 } else {
1172                         /* Assume that dynamic WEP-104 keys will be used and
1173                          * set cipher suites in order for drivers to expect
1174                          * encryption. */
1175                         cipher_pairwise = cipher_group = CIPHER_WEP104;
1176                 }
1177         }
1178 #endif /* IEEE8021X_EAPOL */
1179
1180         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1181                 /* Set the key before (and later after) association */
1182                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1183         }
1184
1185         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1186         if (bss) {
1187                 params.bssid = bss->bssid;
1188                 params.ssid = bss->ssid;
1189                 params.ssid_len = bss->ssid_len;
1190                 params.freq = bss->freq;
1191         } else {
1192                 params.ssid = ssid->ssid;
1193                 params.ssid_len = ssid->ssid_len;
1194         }
1195         if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
1196             params.freq == 0)
1197                 params.freq = ssid->frequency; /* Initial channel for IBSS */
1198         params.wpa_ie = wpa_ie;
1199         params.wpa_ie_len = wpa_ie_len;
1200         params.pairwise_suite = cipher_pairwise;
1201         params.group_suite = cipher_group;
1202         params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1203         params.auth_alg = algs;
1204         params.mode = ssid->mode;
1205         for (i = 0; i < NUM_WEP_KEYS; i++) {
1206                 if (ssid->wep_key_len[i])
1207                         params.wep_key[i] = ssid->wep_key[i];
1208                 params.wep_key_len[i] = ssid->wep_key_len[i];
1209         }
1210         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1211
1212         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1213             (params.key_mgmt_suite == KEY_MGMT_PSK ||
1214              params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1215                 params.passphrase = ssid->passphrase;
1216                 if (ssid->psk_set)
1217                         params.psk = ssid->psk;
1218         }
1219
1220         params.drop_unencrypted = use_crypt;
1221
1222 #ifdef CONFIG_IEEE80211W
1223         params.mgmt_frame_protection = ssid->ieee80211w;
1224         if (ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION && bss) {
1225                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1226                 struct wpa_ie_data ie;
1227                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1228                     ie.capabilities &
1229                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1230                         wpa_printf(MSG_DEBUG, "WPA: Selected AP supports MFP: "
1231                                    "require MFP");
1232                         params.mgmt_frame_protection =
1233                                 MGMT_FRAME_PROTECTION_REQUIRED;
1234                 }
1235         }
1236 #endif /* CONFIG_IEEE80211W */
1237
1238         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1239                 ret = ieee80211_sta_associate(wpa_s, &params);
1240         else
1241                 ret = wpa_drv_associate(wpa_s, &params);
1242         if (ret < 0) {
1243                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1244                         "failed");
1245                 /* try to continue anyway; new association will be tried again
1246                  * after timeout */
1247                 assoc_failed = 1;
1248         }
1249
1250         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1251                 /* Set the key after the association just in case association
1252                  * cleared the previously configured key. */
1253                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1254                 /* No need to timeout authentication since there is no key
1255                  * management. */
1256                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1257                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1258 #ifdef CONFIG_IBSS_RSN
1259         } else if (ssid->mode == WPAS_MODE_IBSS &&
1260                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1261                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1262                 ibss_rsn_set_psk(wpa_s->ibss_rsn, ssid->psk);
1263                 /*
1264                  * RSN IBSS authentication is per-STA and we can disable the
1265                  * per-BSSID authentication.
1266                  */
1267                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1268 #endif /* CONFIG_IBSS_RSN */
1269         } else {
1270                 /* Timeout for IEEE 802.11 authentication and association */
1271                 int timeout = 60;
1272
1273                 if (assoc_failed) {
1274                         /* give IBSS a bit more time */
1275                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
1276                 } else if (wpa_s->conf->ap_scan == 1) {
1277                         /* give IBSS a bit more time */
1278                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
1279                 }
1280                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1281         }
1282
1283         if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1284             capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1285                 /* Set static WEP keys again */
1286                 wpa_set_wep_keys(wpa_s, ssid);
1287         }
1288
1289         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1290                 /*
1291                  * Do not allow EAP session resumption between different
1292                  * network configurations.
1293                  */
1294                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1295         }
1296         old_ssid = wpa_s->current_ssid;
1297         wpa_s->current_ssid = ssid;
1298         wpa_s->current_bss = bss;
1299         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1300         wpa_supplicant_initiate_eapol(wpa_s);
1301         if (old_ssid != wpa_s->current_ssid)
1302                 wpas_notify_network_changed(wpa_s);
1303 }
1304
1305
1306 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1307                                             const u8 *addr)
1308 {
1309         struct wpa_ssid *old_ssid;
1310
1311         wpa_clear_keys(wpa_s, addr);
1312         wpa_supplicant_mark_disassoc(wpa_s);
1313         old_ssid = wpa_s->current_ssid;
1314         wpa_s->current_ssid = NULL;
1315         wpa_s->current_bss = NULL;
1316         wpa_sm_set_config(wpa_s->wpa, NULL);
1317         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1318         if (old_ssid != wpa_s->current_ssid)
1319                 wpas_notify_network_changed(wpa_s);
1320         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1321 }
1322
1323
1324 /**
1325  * wpa_supplicant_disassociate - Disassociate the current connection
1326  * @wpa_s: Pointer to wpa_supplicant data
1327  * @reason_code: IEEE 802.11 reason code for the disassociate frame
1328  *
1329  * This function is used to request %wpa_supplicant to disassociate with the
1330  * current AP.
1331  */
1332 void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1333                                  int reason_code)
1334 {
1335         u8 *addr = NULL;
1336
1337         if (!is_zero_ether_addr(wpa_s->bssid)) {
1338                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1339                         ieee80211_sta_disassociate(wpa_s, reason_code);
1340                 else
1341                         wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1342                 addr = wpa_s->bssid;
1343         }
1344
1345         wpa_supplicant_clear_connection(wpa_s, addr);
1346 }
1347
1348
1349 /**
1350  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1351  * @wpa_s: Pointer to wpa_supplicant data
1352  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1353  *
1354  * This function is used to request %wpa_supplicant to deauthenticate from the
1355  * current AP.
1356  */
1357 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1358                                    int reason_code)
1359 {
1360         u8 *addr = NULL;
1361
1362         if (!is_zero_ether_addr(wpa_s->bssid)) {
1363                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1364                         ieee80211_sta_deauthenticate(wpa_s, reason_code);
1365                 else
1366                         wpa_drv_deauthenticate(wpa_s, wpa_s->bssid,
1367                                                reason_code);
1368                 addr = wpa_s->bssid;
1369         }
1370
1371         wpa_supplicant_clear_connection(wpa_s, addr);
1372 }
1373
1374
1375 /**
1376  * wpa_supplicant_enable_network - Mark a configured network as enabled
1377  * @wpa_s: wpa_supplicant structure for a network interface
1378  * @ssid: wpa_ssid structure for a configured network or %NULL
1379  *
1380  * Enables the specified network or all networks if no network specified.
1381  */
1382 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
1383                                    struct wpa_ssid *ssid)
1384 {
1385         struct wpa_ssid *other_ssid;
1386         int was_disabled;
1387
1388         if (ssid == NULL) {
1389                 other_ssid = wpa_s->conf->ssid;
1390                 while (other_ssid) {
1391                         if (other_ssid == wpa_s->current_ssid &&
1392                             other_ssid->disabled)
1393                                 wpa_s->reassociate = 1;
1394
1395                         was_disabled = other_ssid->disabled;
1396
1397                         other_ssid->disabled = 0;
1398
1399                         if (was_disabled != other_ssid->disabled)
1400                                 wpas_notify_network_enabled_changed(
1401                                         wpa_s, other_ssid);
1402
1403                         other_ssid = other_ssid->next;
1404                 }
1405                 if (wpa_s->reassociate)
1406                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1407         } else if (ssid->disabled) {
1408                 if (wpa_s->current_ssid == NULL) {
1409                         /*
1410                          * Try to reassociate since there is no current
1411                          * configuration and a new network was made available.
1412                          */
1413                         wpa_s->reassociate = 1;
1414                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1415                 }
1416
1417                 was_disabled = ssid->disabled;
1418
1419                 ssid->disabled = 0;
1420
1421                 if (was_disabled != ssid->disabled)
1422                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1423         }
1424 }
1425
1426
1427 /**
1428  * wpa_supplicant_disable_network - Mark a configured network as disabled
1429  * @wpa_s: wpa_supplicant structure for a network interface
1430  * @ssid: wpa_ssid structure for a configured network or %NULL
1431  *
1432  * Disables the specified network or all networks if no network specified.
1433  */
1434 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
1435                                     struct wpa_ssid *ssid)
1436 {
1437         struct wpa_ssid *other_ssid;
1438         int was_disabled;
1439
1440         if (ssid == NULL) {
1441                 other_ssid = wpa_s->conf->ssid;
1442                 while (other_ssid) {
1443                         was_disabled = other_ssid->disabled;
1444
1445                         other_ssid->disabled = 1;
1446
1447                         if (was_disabled != other_ssid->disabled)
1448                                 wpas_notify_network_enabled_changed(
1449                                         wpa_s, other_ssid);
1450
1451                         other_ssid = other_ssid->next;
1452                 }
1453                 if (wpa_s->current_ssid)
1454                         wpa_supplicant_disassociate(
1455                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1456         } else {
1457                 if (ssid == wpa_s->current_ssid)
1458                         wpa_supplicant_disassociate(
1459                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1460
1461                 was_disabled = ssid->disabled;
1462
1463                 ssid->disabled = 1;
1464
1465                 if (was_disabled != ssid->disabled)
1466                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1467         }
1468 }
1469
1470
1471 /**
1472  * wpa_supplicant_select_network - Attempt association with a network
1473  * @wpa_s: wpa_supplicant structure for a network interface
1474  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
1475  */
1476 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
1477                                    struct wpa_ssid *ssid)
1478 {
1479
1480         struct wpa_ssid *other_ssid;
1481
1482         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid)
1483                 wpa_supplicant_disassociate(
1484                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1485
1486         /*
1487          * Mark all other networks disabled or mark all networks enabled if no
1488          * network specified.
1489          */
1490         other_ssid = wpa_s->conf->ssid;
1491         while (other_ssid) {
1492                 int was_disabled = other_ssid->disabled;
1493
1494                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
1495
1496                 if (was_disabled != other_ssid->disabled)
1497                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
1498
1499                 other_ssid = other_ssid->next;
1500         }
1501         wpa_s->disconnected = 0;
1502         wpa_s->reassociate = 1;
1503         wpa_supplicant_req_scan(wpa_s, 0, 0);
1504
1505         if (ssid)
1506                 wpas_notify_network_selected(wpa_s, ssid);
1507 }
1508
1509
1510 /**
1511  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
1512  * @wpa_s: wpa_supplicant structure for a network interface
1513  * @ap_scan: AP scan mode
1514  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
1515  *
1516  */
1517 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
1518 {
1519
1520         int old_ap_scan;
1521
1522         if (ap_scan < 0 || ap_scan > 2)
1523                 return -1;
1524
1525         old_ap_scan = wpa_s->conf->ap_scan;
1526         wpa_s->conf->ap_scan = ap_scan;
1527
1528         if (old_ap_scan != wpa_s->conf->ap_scan)
1529                 wpas_notify_ap_scan_changed(wpa_s);
1530
1531         return 0;
1532 }
1533
1534
1535 /**
1536  * wpa_supplicant_set_debug_params - Set global debug params
1537  * @global: wpa_global structure
1538  * @debug_level: debug level
1539  * @debug_timestamp: determines if show timestamp in debug data
1540  * @debug_show_keys: determines if show keys in debug data
1541  * Returns: 0 if succeed or -1 if debug_level has wrong value
1542  */
1543 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
1544                                     int debug_timestamp, int debug_show_keys)
1545 {
1546
1547         int old_level, old_timestamp, old_show_keys;
1548
1549         /* check for allowed debuglevels */
1550         if (debug_level != MSG_MSGDUMP &&
1551             debug_level != MSG_DEBUG &&
1552             debug_level != MSG_INFO &&
1553             debug_level != MSG_WARNING &&
1554             debug_level != MSG_ERROR)
1555                 return -1;
1556
1557         old_level = wpa_debug_level;
1558         old_timestamp = wpa_debug_timestamp;
1559         old_show_keys = wpa_debug_show_keys;
1560
1561         wpa_debug_level = debug_level;
1562         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
1563         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
1564
1565         if (wpa_debug_level != old_level)
1566                 wpas_notify_debug_level_changed(global);
1567         if (wpa_debug_timestamp != old_timestamp)
1568                 wpas_notify_debug_timestamp_changed(global);
1569         if (wpa_debug_show_keys != old_show_keys)
1570                 wpas_notify_debug_show_keys_changed(global);
1571
1572         return 0;
1573 }
1574
1575
1576 /**
1577  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
1578  * @wpa_s: Pointer to wpa_supplicant data
1579  * Returns: A pointer to the current network structure or %NULL on failure
1580  */
1581 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
1582 {
1583         struct wpa_ssid *entry;
1584         u8 ssid[MAX_SSID_LEN];
1585         int res;
1586         size_t ssid_len;
1587         u8 bssid[ETH_ALEN];
1588         int wired;
1589
1590         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
1591                 if (ieee80211_sta_get_ssid(wpa_s, ssid, &ssid_len)) {
1592                         wpa_printf(MSG_WARNING, "Could not read SSID from "
1593                                    "MLME.");
1594                         return NULL;
1595                 }
1596         } else {
1597                 res = wpa_drv_get_ssid(wpa_s, ssid);
1598                 if (res < 0) {
1599                         wpa_printf(MSG_WARNING, "Could not read SSID from "
1600                                    "driver.");
1601                         return NULL;
1602                 }
1603                 ssid_len = res;
1604         }
1605
1606         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
1607                 os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
1608         else if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
1609                 wpa_printf(MSG_WARNING, "Could not read BSSID from driver.");
1610                 return NULL;
1611         }
1612
1613         wired = wpa_s->conf->ap_scan == 0 &&
1614                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
1615
1616         entry = wpa_s->conf->ssid;
1617         while (entry) {
1618                 if (!entry->disabled &&
1619                     ((ssid_len == entry->ssid_len &&
1620                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
1621                     (!entry->bssid_set ||
1622                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1623                         return entry;
1624 #ifdef CONFIG_WPS
1625                 if (!entry->disabled &&
1626                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
1627                     (entry->ssid == NULL || entry->ssid_len == 0) &&
1628                     (!entry->bssid_set ||
1629                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1630                         return entry;
1631 #endif /* CONFIG_WPS */
1632                 entry = entry->next;
1633         }
1634
1635         return NULL;
1636 }
1637
1638
1639 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
1640                                      const char *name)
1641 {
1642         int i;
1643         size_t len;
1644         const char *pos;
1645
1646         if (wpa_s == NULL)
1647                 return -1;
1648
1649         if (wpa_drivers[0] == NULL) {
1650                 wpa_printf(MSG_ERROR, "No driver interfaces build into "
1651                            "wpa_supplicant.");
1652                 return -1;
1653         }
1654
1655         if (name == NULL) {
1656                 /* default to first driver in the list */
1657                 wpa_s->driver = wpa_drivers[0];
1658                 wpa_s->global_drv_priv = wpa_s->global->drv_priv[0];
1659                 return 0;
1660         }
1661
1662         pos = os_strchr(name, ',');
1663         if (pos)
1664                 len = pos - name;
1665         else
1666                 len = os_strlen(name);
1667         for (i = 0; wpa_drivers[i]; i++) {
1668                 if (os_strlen(wpa_drivers[i]->name) == len &&
1669                     os_strncmp(name, wpa_drivers[i]->name, len) ==
1670                     0) {
1671                         wpa_s->driver = wpa_drivers[i];
1672                         wpa_s->global_drv_priv = wpa_s->global->drv_priv[i];
1673                         return 0;
1674                 }
1675         }
1676
1677         wpa_printf(MSG_ERROR, "Unsupported driver '%s'.", name);
1678         return -1;
1679 }
1680
1681
1682 /**
1683  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
1684  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
1685  *      with struct wpa_driver_ops::init()
1686  * @src_addr: Source address of the EAPOL frame
1687  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
1688  * @len: Length of the EAPOL data
1689  *
1690  * This function is called for each received EAPOL frame. Most driver
1691  * interfaces rely on more generic OS mechanism for receiving frames through
1692  * l2_packet, but if such a mechanism is not available, the driver wrapper may
1693  * take care of received EAPOL frames and deliver them to the core supplicant
1694  * code by calling this function.
1695  */
1696 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1697                              const u8 *buf, size_t len)
1698 {
1699         struct wpa_supplicant *wpa_s = ctx;
1700
1701         wpa_printf(MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
1702         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
1703
1704         if (wpa_s->wpa_state < WPA_ASSOCIATED) {
1705                 /*
1706                  * There is possible race condition between receiving the
1707                  * association event and the EAPOL frame since they are coming
1708                  * through different paths from the driver. In order to avoid
1709                  * issues in trying to process the EAPOL frame before receiving
1710                  * association information, lets queue it for processing until
1711                  * the association event is received.
1712                  */
1713                 wpa_printf(MSG_DEBUG, "Not associated - Delay processing of "
1714                            "received EAPOL frame");
1715                 wpabuf_free(wpa_s->pending_eapol_rx);
1716                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
1717                 if (wpa_s->pending_eapol_rx) {
1718                         os_get_time(&wpa_s->pending_eapol_rx_time);
1719                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
1720                                   ETH_ALEN);
1721                 }
1722                 return;
1723         }
1724
1725 #ifdef CONFIG_AP
1726         if (wpa_s->ap_iface) {
1727                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
1728                 return;
1729         }
1730 #endif /* CONFIG_AP */
1731
1732         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
1733                 wpa_printf(MSG_DEBUG, "Ignored received EAPOL frame since "
1734                            "no key management is configured");
1735                 return;
1736         }
1737
1738         if (wpa_s->eapol_received == 0 &&
1739             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
1740              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
1741              wpa_s->wpa_state != WPA_COMPLETED) &&
1742             (wpa_s->current_ssid == NULL ||
1743              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
1744                 /* Timeout for completing IEEE 802.1X and WPA authentication */
1745                 wpa_supplicant_req_auth_timeout(
1746                         wpa_s,
1747                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
1748                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
1749                          wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
1750                         70 : 10, 0);
1751         }
1752         wpa_s->eapol_received++;
1753
1754         if (wpa_s->countermeasures) {
1755                 wpa_printf(MSG_INFO, "WPA: Countermeasures - dropped EAPOL "
1756                            "packet");
1757                 return;
1758         }
1759
1760 #ifdef CONFIG_IBSS_RSN
1761         if (wpa_s->current_ssid &&
1762             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
1763                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
1764                 return;
1765         }
1766 #endif /* CONFIG_IBSS_RSN */
1767
1768         /* Source address of the incoming EAPOL frame could be compared to the
1769          * current BSSID. However, it is possible that a centralized
1770          * Authenticator could be using another MAC address than the BSSID of
1771          * an AP, so just allow any address to be used for now. The replies are
1772          * still sent to the current BSSID (if available), though. */
1773
1774         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
1775         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
1776             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
1777                 return;
1778         wpa_drv_poll(wpa_s);
1779         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
1780                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
1781         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
1782                 /*
1783                  * Set portValid = TRUE here since we are going to skip 4-way
1784                  * handshake processing which would normally set portValid. We
1785                  * need this to allow the EAPOL state machines to be completed
1786                  * without going through EAPOL-Key handshake.
1787                  */
1788                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1789         }
1790 }
1791
1792
1793 /**
1794  * wpa_supplicant_driver_init - Initialize driver interface parameters
1795  * @wpa_s: Pointer to wpa_supplicant data
1796  * Returns: 0 on success, -1 on failure
1797  *
1798  * This function is called to initialize driver interface parameters.
1799  * wpa_drv_init() must have been called before this function to initialize the
1800  * driver interface.
1801  */
1802 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
1803 {
1804         static int interface_count = 0;
1805
1806         if (wpa_s->driver->send_eapol) {
1807                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
1808                 if (addr)
1809                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
1810         } else {
1811                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
1812                                            wpa_drv_get_mac_addr(wpa_s),
1813                                            ETH_P_EAPOL,
1814                                            wpa_supplicant_rx_eapol, wpa_s, 0);
1815                 if (wpa_s->l2 == NULL)
1816                         return -1;
1817         }
1818
1819         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
1820                 wpa_printf(MSG_ERROR, "Failed to get own L2 address");
1821                 return -1;
1822         }
1823
1824         wpa_printf(MSG_DEBUG, "Own MAC address: " MACSTR,
1825                    MAC2STR(wpa_s->own_addr));
1826
1827         if (wpa_s->bridge_ifname[0]) {
1828                 wpa_printf(MSG_DEBUG, "Receiving packets from bridge interface"
1829                            " '%s'", wpa_s->bridge_ifname);
1830                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
1831                                               wpa_s->own_addr,
1832                                               ETH_P_EAPOL,
1833                                               wpa_supplicant_rx_eapol, wpa_s,
1834                                               0);
1835                 if (wpa_s->l2_br == NULL) {
1836                         wpa_printf(MSG_ERROR, "Failed to open l2_packet "
1837                                    "connection for the bridge interface '%s'",
1838                                    wpa_s->bridge_ifname);
1839                         return -1;
1840                 }
1841         }
1842
1843         wpa_clear_keys(wpa_s, NULL);
1844
1845         /* Make sure that TKIP countermeasures are not left enabled (could
1846          * happen if wpa_supplicant is killed during countermeasures. */
1847         wpa_drv_set_countermeasures(wpa_s, 0);
1848
1849         wpa_printf(MSG_DEBUG, "RSN: flushing PMKID list in the driver");
1850         wpa_drv_flush_pmkid(wpa_s);
1851
1852         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
1853         if (wpa_supplicant_enabled_networks(wpa_s->conf)) {
1854                 wpa_supplicant_req_scan(wpa_s, interface_count, 100000);
1855                 interface_count++;
1856         } else
1857                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
1858
1859         return 0;
1860 }
1861
1862
1863 static int wpa_supplicant_daemon(const char *pid_file)
1864 {
1865         wpa_printf(MSG_DEBUG, "Daemonize..");
1866         return os_daemonize(pid_file);
1867 }
1868
1869
1870 static struct wpa_supplicant * wpa_supplicant_alloc(void)
1871 {
1872         struct wpa_supplicant *wpa_s;
1873
1874         wpa_s = os_zalloc(sizeof(*wpa_s));
1875         if (wpa_s == NULL)
1876                 return NULL;
1877         wpa_s->scan_req = 1;
1878         wpa_s->new_connection = 1;
1879
1880         return wpa_s;
1881 }
1882
1883
1884 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
1885                                      struct wpa_interface *iface)
1886 {
1887         const char *ifname, *driver;
1888         struct wpa_driver_capa capa;
1889
1890         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
1891                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
1892                    iface->confname ? iface->confname : "N/A",
1893                    iface->driver ? iface->driver : "default",
1894                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
1895                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
1896
1897         if (iface->confname) {
1898 #ifdef CONFIG_BACKEND_FILE
1899                 wpa_s->confname = os_rel2abs_path(iface->confname);
1900                 if (wpa_s->confname == NULL) {
1901                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
1902                                    "for configuration file '%s'.",
1903                                    iface->confname);
1904                         return -1;
1905                 }
1906                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
1907                            iface->confname, wpa_s->confname);
1908 #else /* CONFIG_BACKEND_FILE */
1909                 wpa_s->confname = os_strdup(iface->confname);
1910 #endif /* CONFIG_BACKEND_FILE */
1911                 wpa_s->conf = wpa_config_read(wpa_s->confname);
1912                 if (wpa_s->conf == NULL) {
1913                         wpa_printf(MSG_ERROR, "Failed to read or parse "
1914                                    "configuration '%s'.", wpa_s->confname);
1915                         return -1;
1916                 }
1917
1918                 /*
1919                  * Override ctrl_interface and driver_param if set on command
1920                  * line.
1921                  */
1922                 if (iface->ctrl_interface) {
1923                         os_free(wpa_s->conf->ctrl_interface);
1924                         wpa_s->conf->ctrl_interface =
1925                                 os_strdup(iface->ctrl_interface);
1926                 }
1927
1928                 if (iface->driver_param) {
1929                         os_free(wpa_s->conf->driver_param);
1930                         wpa_s->conf->driver_param =
1931                                 os_strdup(iface->driver_param);
1932                 }
1933         } else
1934                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
1935                                                      iface->driver_param);
1936
1937         if (wpa_s->conf == NULL) {
1938                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
1939                 return -1;
1940         }
1941
1942         if (iface->ifname == NULL) {
1943                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
1944                 return -1;
1945         }
1946         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
1947                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
1948                            iface->ifname);
1949                 return -1;
1950         }
1951         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
1952
1953         if (iface->bridge_ifname) {
1954                 if (os_strlen(iface->bridge_ifname) >=
1955                     sizeof(wpa_s->bridge_ifname)) {
1956                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
1957                                    "name '%s'.", iface->bridge_ifname);
1958                         return -1;
1959                 }
1960                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
1961                            sizeof(wpa_s->bridge_ifname));
1962         }
1963
1964         /* RSNA Supplicant Key Management - INITIALIZE */
1965         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1966         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1967
1968         /* Initialize driver interface and register driver event handler before
1969          * L2 receive handler so that association events are processed before
1970          * EAPOL-Key packets if both become available for the same select()
1971          * call. */
1972         driver = iface->driver;
1973 next_driver:
1974         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
1975                 return -1;
1976
1977         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
1978         if (wpa_s->drv_priv == NULL) {
1979                 const char *pos;
1980                 pos = driver ? os_strchr(driver, ',') : NULL;
1981                 if (pos) {
1982                         wpa_printf(MSG_DEBUG, "Failed to initialize driver "
1983                                    "interface - try next driver wrapper");
1984                         driver = pos + 1;
1985                         goto next_driver;
1986                 }
1987                 wpa_printf(MSG_ERROR, "Failed to initialize driver interface");
1988                 return -1;
1989         }
1990         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
1991                 wpa_printf(MSG_ERROR, "Driver interface rejected "
1992                            "driver_param '%s'", wpa_s->conf->driver_param);
1993                 return -1;
1994         }
1995
1996         ifname = wpa_drv_get_ifname(wpa_s);
1997         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
1998                 wpa_printf(MSG_DEBUG, "Driver interface replaced interface "
1999                            "name with '%s'", ifname);
2000                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2001         }
2002
2003         if (wpa_supplicant_init_wpa(wpa_s) < 0)
2004                 return -1;
2005
2006         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
2007                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
2008                           NULL);
2009         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
2010
2011         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
2012             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
2013                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
2014                 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
2015                            "dot11RSNAConfigPMKLifetime");
2016                 return -1;
2017         }
2018
2019         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
2020             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
2021                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
2022                 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
2023                         "dot11RSNAConfigPMKReauthThreshold");
2024                 return -1;
2025         }
2026
2027         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
2028             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
2029                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
2030                 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
2031                            "dot11RSNAConfigSATimeout");
2032                 return -1;
2033         }
2034
2035         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
2036                 wpa_s->drv_flags = capa.flags;
2037                 if (capa.flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
2038                         if (ieee80211_sta_init(wpa_s))
2039                                 return -1;
2040                 }
2041                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
2042                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
2043         }
2044         if (wpa_s->max_remain_on_chan == 0)
2045                 wpa_s->max_remain_on_chan = 1000;
2046
2047         if (wpa_supplicant_driver_init(wpa_s) < 0)
2048                 return -1;
2049
2050         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
2051             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
2052                 wpa_printf(MSG_DEBUG, "Failed to set country");
2053                 return -1;
2054         }
2055
2056         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2057
2058         if (wpas_wps_init(wpa_s))
2059                 return -1;
2060
2061         if (wpa_supplicant_init_eapol(wpa_s) < 0)
2062                 return -1;
2063         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2064
2065         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
2066         if (wpa_s->ctrl_iface == NULL) {
2067                 wpa_printf(MSG_ERROR,
2068                            "Failed to initialize control interface '%s'.\n"
2069                            "You may have another wpa_supplicant process "
2070                            "already running or the file was\n"
2071                            "left by an unclean termination of wpa_supplicant "
2072                            "in which case you will need\n"
2073                            "to manually remove this file before starting "
2074                            "wpa_supplicant again.\n",
2075                            wpa_s->conf->ctrl_interface);
2076                 return -1;
2077         }
2078
2079 #ifdef CONFIG_IBSS_RSN
2080         wpa_s->ibss_rsn = ibss_rsn_init(wpa_s);
2081         if (!wpa_s->ibss_rsn) {
2082                 wpa_printf(MSG_DEBUG, "Failed to init IBSS RSN");
2083                 return -1;
2084         }
2085 #endif /* CONFIG_IBSS_RSN */
2086
2087         if (wpa_bss_init(wpa_s) < 0)
2088                 return -1;
2089
2090         return 0;
2091 }
2092
2093
2094 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
2095                                         int notify)
2096 {
2097         if (wpa_s->drv_priv) {
2098                 wpa_supplicant_deauthenticate(wpa_s,
2099                                               WLAN_REASON_DEAUTH_LEAVING);
2100
2101                 wpa_drv_set_countermeasures(wpa_s, 0);
2102                 wpa_clear_keys(wpa_s, NULL);
2103         }
2104
2105         wpa_supplicant_cleanup(wpa_s);
2106
2107         if (notify)
2108                 wpas_notify_iface_removed(wpa_s);
2109
2110         if (wpa_s->drv_priv)
2111                 wpa_drv_deinit(wpa_s);
2112 }
2113
2114
2115 /**
2116  * wpa_supplicant_add_iface - Add a new network interface
2117  * @global: Pointer to global data from wpa_supplicant_init()
2118  * @iface: Interface configuration options
2119  * Returns: Pointer to the created interface or %NULL on failure
2120  *
2121  * This function is used to add new network interfaces for %wpa_supplicant.
2122  * This can be called before wpa_supplicant_run() to add interfaces before the
2123  * main event loop has been started. In addition, new interfaces can be added
2124  * dynamically while %wpa_supplicant is already running. This could happen,
2125  * e.g., when a hotplug network adapter is inserted.
2126  */
2127 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
2128                                                  struct wpa_interface *iface)
2129 {
2130         struct wpa_supplicant *wpa_s;
2131         struct wpa_interface t_iface;
2132         struct wpa_ssid *ssid;
2133
2134         if (global == NULL || iface == NULL)
2135                 return NULL;
2136
2137         wpa_s = wpa_supplicant_alloc();
2138         if (wpa_s == NULL)
2139                 return NULL;
2140
2141         wpa_s->global = global;
2142
2143         t_iface = *iface;
2144         if (global->params.override_driver) {
2145                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
2146                            "('%s' -> '%s')",
2147                            iface->driver, global->params.override_driver);
2148                 t_iface.driver = global->params.override_driver;
2149         }
2150         if (global->params.override_ctrl_interface) {
2151                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
2152                            "ctrl_interface ('%s' -> '%s')",
2153                            iface->ctrl_interface,
2154                            global->params.override_ctrl_interface);
2155                 t_iface.ctrl_interface =
2156                         global->params.override_ctrl_interface;
2157         }
2158         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
2159                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
2160                            iface->ifname);
2161                 wpa_supplicant_deinit_iface(wpa_s, 0);
2162                 os_free(wpa_s);
2163                 return NULL;
2164         }
2165
2166         /* Notify the control interfaces about new iface */
2167         if (wpas_notify_iface_added(wpa_s)) {
2168                 wpa_supplicant_deinit_iface(wpa_s, 1);
2169                 os_free(wpa_s);
2170                 return NULL;
2171         }
2172
2173         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2174                 wpas_notify_network_added(wpa_s, ssid);
2175
2176         wpa_s->next = global->ifaces;
2177         global->ifaces = wpa_s;
2178
2179         wpa_printf(MSG_DEBUG, "Added interface %s", wpa_s->ifname);
2180
2181         return wpa_s;
2182 }
2183
2184
2185 /**
2186  * wpa_supplicant_remove_iface - Remove a network interface
2187  * @global: Pointer to global data from wpa_supplicant_init()
2188  * @wpa_s: Pointer to the network interface to be removed
2189  * Returns: 0 if interface was removed, -1 if interface was not found
2190  *
2191  * This function can be used to dynamically remove network interfaces from
2192  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
2193  * addition, this function is used to remove all remaining interfaces when
2194  * %wpa_supplicant is terminated.
2195  */
2196 int wpa_supplicant_remove_iface(struct wpa_global *global,
2197                                 struct wpa_supplicant *wpa_s)
2198 {
2199         struct wpa_supplicant *prev;
2200
2201         /* Remove interface from the global list of interfaces */
2202         prev = global->ifaces;
2203         if (prev == wpa_s) {
2204                 global->ifaces = wpa_s->next;
2205         } else {
2206                 while (prev && prev->next != wpa_s)
2207                         prev = prev->next;
2208                 if (prev == NULL)
2209                         return -1;
2210                 prev->next = wpa_s->next;
2211         }
2212
2213         wpa_printf(MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
2214
2215         wpa_supplicant_deinit_iface(wpa_s, 1);
2216         os_free(wpa_s);
2217
2218         return 0;
2219 }
2220
2221
2222 /**
2223  * wpa_supplicant_get_iface - Get a new network interface
2224  * @global: Pointer to global data from wpa_supplicant_init()
2225  * @ifname: Interface name
2226  * Returns: Pointer to the interface or %NULL if not found
2227  */
2228 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
2229                                                  const char *ifname)
2230 {
2231         struct wpa_supplicant *wpa_s;
2232
2233         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
2234                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
2235                         return wpa_s;
2236         }
2237         return NULL;
2238 }
2239
2240
2241 /**
2242  * wpa_supplicant_init - Initialize %wpa_supplicant
2243  * @params: Parameters for %wpa_supplicant
2244  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
2245  *
2246  * This function is used to initialize %wpa_supplicant. After successful
2247  * initialization, the returned data pointer can be used to add and remove
2248  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
2249  */
2250 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
2251 {
2252         struct wpa_global *global;
2253         int ret, i;
2254
2255         if (params == NULL)
2256                 return NULL;
2257
2258         wpa_debug_open_file(params->wpa_debug_file_path);
2259         if (params->wpa_debug_syslog)
2260                 wpa_debug_open_syslog();
2261
2262         ret = eap_register_methods();
2263         if (ret) {
2264                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
2265                 if (ret == -2)
2266                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
2267                                    "the same EAP type.");
2268                 return NULL;
2269         }
2270
2271         global = os_zalloc(sizeof(*global));
2272         if (global == NULL)
2273                 return NULL;
2274         global->params.daemonize = params->daemonize;
2275         global->params.wait_for_monitor = params->wait_for_monitor;
2276         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
2277         if (params->pid_file)
2278                 global->params.pid_file = os_strdup(params->pid_file);
2279         if (params->ctrl_interface)
2280                 global->params.ctrl_interface =
2281                         os_strdup(params->ctrl_interface);
2282         if (params->override_driver)
2283                 global->params.override_driver =
2284                         os_strdup(params->override_driver);
2285         if (params->override_ctrl_interface)
2286                 global->params.override_ctrl_interface =
2287                         os_strdup(params->override_ctrl_interface);
2288         wpa_debug_level = global->params.wpa_debug_level =
2289                 params->wpa_debug_level;
2290         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
2291                 params->wpa_debug_show_keys;
2292         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
2293                 params->wpa_debug_timestamp;
2294
2295         if (eloop_init()) {
2296                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
2297                 wpa_supplicant_deinit(global);
2298                 return NULL;
2299         }
2300
2301         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
2302         if (global->ctrl_iface == NULL) {
2303                 wpa_supplicant_deinit(global);
2304                 return NULL;
2305         }
2306
2307         if (wpas_notify_supplicant_initialized(global)) {
2308                 wpa_supplicant_deinit(global);
2309                 return NULL;
2310         }
2311
2312         for (i = 0; wpa_drivers[i]; i++)
2313                 global->drv_count++;
2314         if (global->drv_count == 0) {
2315                 wpa_printf(MSG_ERROR, "No drivers enabled");
2316                 wpa_supplicant_deinit(global);
2317                 return NULL;
2318         }
2319         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
2320         if (global->drv_priv == NULL) {
2321                 wpa_supplicant_deinit(global);
2322                 return NULL;
2323         }
2324         for (i = 0; wpa_drivers[i]; i++) {
2325                 if (!wpa_drivers[i]->global_init)
2326                         continue;
2327                 global->drv_priv[i] = wpa_drivers[i]->global_init();
2328                 if (global->drv_priv[i] == NULL) {
2329                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
2330                                    "'%s'", wpa_drivers[i]->name);
2331                         wpa_supplicant_deinit(global);
2332                         return NULL;
2333                 }
2334         }
2335
2336         return global;
2337 }
2338
2339
2340 /**
2341  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
2342  * @global: Pointer to global data from wpa_supplicant_init()
2343  * Returns: 0 after successful event loop run, -1 on failure
2344  *
2345  * This function starts the main event loop and continues running as long as
2346  * there are any remaining events. In most cases, this function is running as
2347  * long as the %wpa_supplicant process in still in use.
2348  */
2349 int wpa_supplicant_run(struct wpa_global *global)
2350 {
2351         struct wpa_supplicant *wpa_s;
2352
2353         if (global->params.daemonize &&
2354             wpa_supplicant_daemon(global->params.pid_file))
2355                 return -1;
2356
2357         if (global->params.wait_for_monitor) {
2358                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
2359                         if (wpa_s->ctrl_iface)
2360                                 wpa_supplicant_ctrl_iface_wait(
2361                                         wpa_s->ctrl_iface);
2362         }
2363
2364         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
2365         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
2366
2367         eloop_run();
2368
2369         return 0;
2370 }
2371
2372
2373 /**
2374  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
2375  * @global: Pointer to global data from wpa_supplicant_init()
2376  *
2377  * This function is called to deinitialize %wpa_supplicant and to free all
2378  * allocated resources. Remaining network interfaces will also be removed.
2379  */
2380 void wpa_supplicant_deinit(struct wpa_global *global)
2381 {
2382         int i;
2383
2384         if (global == NULL)
2385                 return;
2386
2387         while (global->ifaces)
2388                 wpa_supplicant_remove_iface(global, global->ifaces);
2389
2390         if (global->ctrl_iface)
2391                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
2392
2393         wpas_notify_supplicant_deinitialized(global);
2394
2395         eap_peer_unregister_methods();
2396 #ifdef CONFIG_AP
2397         eap_server_unregister_methods();
2398 #endif /* CONFIG_AP */
2399
2400         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
2401                 if (!global->drv_priv[i])
2402                         continue;
2403                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
2404         }
2405         os_free(global->drv_priv);
2406
2407         eloop_destroy();
2408
2409         if (global->params.pid_file) {
2410                 os_daemonize_terminate(global->params.pid_file);
2411                 os_free(global->params.pid_file);
2412         }
2413         os_free(global->params.ctrl_interface);
2414         os_free(global->params.override_driver);
2415         os_free(global->params.override_ctrl_interface);
2416
2417         os_free(global);
2418         wpa_debug_close_syslog();
2419         wpa_debug_close_file();
2420 }
2421
2422
2423 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
2424 {
2425 #ifdef CONFIG_WPS
2426         wpas_wps_update_config(wpa_s);
2427 #endif /* CONFIG_WPS */
2428
2429         wpa_s->conf->changed_parameters = 0;
2430 }