wpa_supplicant/wpa_supplicant.c

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