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