wpa_supplicant/wpa_supplicant.c

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