git.maemo.org Git - wpasupplicant/blob - wpa_supplicant/wpa_supplicant.c

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