wpa_supplicant/wpa_supplicant.c

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