wpa_supplicant/wpa_supplicant.c

   1 /*
   2  * WPA Supplicant
   3  * Copyright (c) 2003-2011, 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 "crypto/random.h"
  23 #include "crypto/sha1.h"
  24 #include "eapol_supp/eapol_supp_sm.h"
  25 #include "eap_peer/eap.h"
  26 #include "eap_server/eap_methods.h"
  27 #include "rsn_supp/wpa.h"
  28 #include "eloop.h"
  29 #include "config.h"
  30 #include "l2_packet/l2_packet.h"
  31 #include "wpa_supplicant_i.h"
  32 #include "driver_i.h"
  33 #include "ctrl_iface.h"
  34 #include "pcsc_funcs.h"
  35 #include "common/version.h"
  36 #include "rsn_supp/preauth.h"
  37 #include "rsn_supp/pmksa_cache.h"
  38 #include "common/wpa_ctrl.h"
  39 #include "common/ieee802_11_defs.h"
  40 #include "p2p/p2p.h"
  41 #include "blacklist.h"
  42 #include "wpas_glue.h"
  43 #include "wps_supplicant.h"
  44 #include "ibss_rsn.h"
  45 #include "sme.h"
  46 #include "gas_query.h"
  47 #include "ap.h"
  48 #include "p2p_supplicant.h"
  49 #include "notify.h"
  50 #include "bgscan.h"
  51 #include "bss.h"
  52 #include "scan.h"
  53 #include "offchannel.h"
  54
  55 const char *wpa_supplicant_version =
  56 "wpa_supplicant v" VERSION_STR "\n"
  57 "Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi> and contributors";
  58
  59 const char *wpa_supplicant_license =
  60 "This program is free software. You can distribute it and/or modify it\n"
  61 "under the terms of the GNU General Public License version 2.\n"
  62 "\n"
  63 "Alternatively, this software may be distributed under the terms of the\n"
  64 "BSD license. See README and COPYING for more details.\n"
  65 #ifdef EAP_TLS_OPENSSL
  66 "\nThis product includes software developed by the OpenSSL Project\n"
  67 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
  68 #endif /* EAP_TLS_OPENSSL */
  69 ;
  70
  71 #ifndef CONFIG_NO_STDOUT_DEBUG
  72 /* Long text divided into parts in order to fit in C89 strings size limits. */
  73 const char *wpa_supplicant_full_license1 =
  74 "This program is free software; you can redistribute it and/or modify\n"
  75 "it under the terms of the GNU General Public License version 2 as\n"
  76 "published by the Free Software Foundation.\n"
  77 "\n"
  78 "This program is distributed in the hope that it will be useful,\n"
  79 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
  80 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
  81 "GNU General Public License for more details.\n"
  82 "\n";
  83 const char *wpa_supplicant_full_license2 =
  84 "You should have received a copy of the GNU General Public License\n"
  85 "along with this program; if not, write to the Free Software\n"
  86 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\n"
  87 "\n"
  88 "Alternatively, this software may be distributed under the terms of the\n"
  89 "BSD license.\n"
  90 "\n"
  91 "Redistribution and use in source and binary forms, with or without\n"
  92 "modification, are permitted provided that the following conditions are\n"
  93 "met:\n"
  94 "\n";
  95 const char *wpa_supplicant_full_license3 =
  96 "1. Redistributions of source code must retain the above copyright\n"
  97 "   notice, this list of conditions and the following disclaimer.\n"
  98 "\n"
  99 "2. Redistributions in binary form must reproduce the above copyright\n"
 100 "   notice, this list of conditions and the following disclaimer in the\n"
 101 "   documentation and/or other materials provided with the distribution.\n"
 102 "\n";
 103 const char *wpa_supplicant_full_license4 =
 104 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
 105 "   names of its contributors may be used to endorse or promote products\n"
 106 "   derived from this software without specific prior written permission.\n"
 107 "\n"
 108 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
 109 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
 110 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
 111 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
 112 const char *wpa_supplicant_full_license5 =
 113 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
 114 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
 115 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
 116 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
 117 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
 118 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
 119 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
 120 "\n";
 121 #endif /* CONFIG_NO_STDOUT_DEBUG */
 122
 123 extern int wpa_debug_level;
 124 extern int wpa_debug_show_keys;
 125 extern int wpa_debug_timestamp;
 126 extern struct wpa_driver_ops *wpa_drivers[];
 127
 128 /* Configure default/group WEP keys for static WEP */
 129 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
 130 {
 131         int i, set = 0;
 132
 133         for (i = 0; i < NUM_WEP_KEYS; i++) {
 134                 if (ssid->wep_key_len[i] == 0)
 135                         continue;
 136
 137                 set = 1;
 138                 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
 139                                 i, i == ssid->wep_tx_keyidx, NULL, 0,
 140                                 ssid->wep_key[i], ssid->wep_key_len[i]);
 141         }
 142
 143         return set;
 144 }
 145
 146
 147 static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
 148                                            struct wpa_ssid *ssid)
 149 {
 150         u8 key[32];
 151         size_t keylen;
 152         enum wpa_alg alg;
 153         u8 seq[6] = { 0 };
 154
 155         /* IBSS/WPA-None uses only one key (Group) for both receiving and
 156          * sending unicast and multicast packets. */
 157
 158         if (ssid->mode != WPAS_MODE_IBSS) {
 159                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
 160                         "IBSS/ad-hoc) for WPA-None", ssid->mode);
 161                 return -1;
 162         }
 163
 164         if (!ssid->psk_set) {
 165                 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
 166                         "WPA-None");
 167                 return -1;
 168         }
 169
 170         switch (wpa_s->group_cipher) {
 171         case WPA_CIPHER_CCMP:
 172                 os_memcpy(key, ssid->psk, 16);
 173                 keylen = 16;
 174                 alg = WPA_ALG_CCMP;
 175                 break;
 176         case WPA_CIPHER_TKIP:
 177                 /* WPA-None uses the same Michael MIC key for both TX and RX */
 178                 os_memcpy(key, ssid->psk, 16 + 8);
 179                 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
 180                 keylen = 32;
 181                 alg = WPA_ALG_TKIP;
 182                 break;
 183         default:
 184                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
 185                         "WPA-None", wpa_s->group_cipher);
 186                 return -1;
 187         }
 188
 189         /* TODO: should actually remember the previously used seq#, both for TX
 190          * and RX from each STA.. */
 191
 192         return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
 193 }
 194
 195
 196 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
 197 {
 198         struct wpa_supplicant *wpa_s = eloop_ctx;
 199         const u8 *bssid = wpa_s->bssid;
 200         if (is_zero_ether_addr(bssid))
 201                 bssid = wpa_s->pending_bssid;
 202         wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
 203                 MAC2STR(bssid));
 204         wpa_blacklist_add(wpa_s, bssid);
 205         wpa_sm_notify_disassoc(wpa_s->wpa);
 206         wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 207         wpa_s->reassociate = 1;
 208
 209         /*
 210          * If we timed out, the AP or the local radio may be busy.
 211          * So, wait a second until scanning again.
 212          */
 213         wpa_supplicant_req_scan(wpa_s, 1, 0);
 214 }
 215
 216
 217 /**
 218  * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
 219  * @wpa_s: Pointer to wpa_supplicant data
 220  * @sec: Number of seconds after which to time out authentication
 221  * @usec: Number of microseconds after which to time out authentication
 222  *
 223  * This function is used to schedule a timeout for the current authentication
 224  * attempt.
 225  */
 226 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
 227                                      int sec, int usec)
 228 {
 229         if (wpa_s->conf && wpa_s->conf->ap_scan == 0 &&
 230             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 231                 return;
 232
 233         wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
 234                 "%d usec", sec, usec);
 235         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 236         eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
 237 }
 238
 239
 240 /**
 241  * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
 242  * @wpa_s: Pointer to wpa_supplicant data
 243  *
 244  * This function is used to cancel authentication timeout scheduled with
 245  * wpa_supplicant_req_auth_timeout() and it is called when authentication has
 246  * been completed.
 247  */
 248 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
 249 {
 250         wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
 251         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 252         wpa_blacklist_del(wpa_s, wpa_s->bssid);
 253 }
 254
 255
 256 /**
 257  * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
 258  * @wpa_s: Pointer to wpa_supplicant data
 259  *
 260  * This function is used to configure EAPOL state machine based on the selected
 261  * authentication mode.
 262  */
 263 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
 264 {
 265 #ifdef IEEE8021X_EAPOL
 266         struct eapol_config eapol_conf;
 267         struct wpa_ssid *ssid = wpa_s->current_ssid;
 268
 269 #ifdef CONFIG_IBSS_RSN
 270         if (ssid->mode == WPAS_MODE_IBSS &&
 271             wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
 272             wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
 273                 /*
 274                  * RSN IBSS authentication is per-STA and we can disable the
 275                  * per-BSSID EAPOL authentication.
 276                  */
 277                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 278                 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
 279                 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 280                 return;
 281         }
 282 #endif /* CONFIG_IBSS_RSN */
 283
 284         eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 285         eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 286
 287         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
 288             wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
 289                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 290         else
 291                 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
 292
 293         os_memset(&eapol_conf, 0, sizeof(eapol_conf));
 294         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 295                 eapol_conf.accept_802_1x_keys = 1;
 296                 eapol_conf.required_keys = 0;
 297                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
 298                         eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
 299                 }
 300                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
 301                         eapol_conf.required_keys |=
 302                                 EAPOL_REQUIRE_KEY_BROADCAST;
 303                 }
 304
 305                 if (wpa_s->conf && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 306                         eapol_conf.required_keys = 0;
 307         }
 308         if (wpa_s->conf)
 309                 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
 310         eapol_conf.workaround = ssid->eap_workaround;
 311         eapol_conf.eap_disabled =
 312                 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
 313                 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
 314                 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
 315         eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
 316 #endif /* IEEE8021X_EAPOL */
 317 }
 318
 319
 320 /**
 321  * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
 322  * @wpa_s: Pointer to wpa_supplicant data
 323  * @ssid: Configuration data for the network
 324  *
 325  * This function is used to configure WPA state machine and related parameters
 326  * to a mode where WPA is not enabled. This is called as part of the
 327  * authentication configuration when the selected network does not use WPA.
 328  */
 329 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
 330                                        struct wpa_ssid *ssid)
 331 {
 332         int i;
 333
 334         if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
 335                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
 336         else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
 337                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 338         else
 339                 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
 340         wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
 341         wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
 342         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 343         wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 344         wpa_s->group_cipher = WPA_CIPHER_NONE;
 345         wpa_s->mgmt_group_cipher = 0;
 346
 347         for (i = 0; i < NUM_WEP_KEYS; i++) {
 348                 if (ssid->wep_key_len[i] > 5) {
 349                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
 350                         wpa_s->group_cipher = WPA_CIPHER_WEP104;
 351                         break;
 352                 } else if (ssid->wep_key_len[i] > 0) {
 353                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
 354                         wpa_s->group_cipher = WPA_CIPHER_WEP40;
 355                         break;
 356                 }
 357         }
 358
 359         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
 360         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 361         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 362                          wpa_s->pairwise_cipher);
 363         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 364 #ifdef CONFIG_IEEE80211W
 365         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 366                          wpa_s->mgmt_group_cipher);
 367 #endif /* CONFIG_IEEE80211W */
 368
 369         pmksa_cache_clear_current(wpa_s->wpa);
 370 }
 371
 372
 373 static void free_hw_features(struct wpa_supplicant *wpa_s)
 374 {
 375         int i;
 376         if (wpa_s->hw.modes == NULL)
 377                 return;
 378
 379         for (i = 0; i < wpa_s->hw.num_modes; i++) {
 380                 os_free(wpa_s->hw.modes[i].channels);
 381                 os_free(wpa_s->hw.modes[i].rates);
 382         }
 383
 384         os_free(wpa_s->hw.modes);
 385         wpa_s->hw.modes = NULL;
 386 }
 387
 388
 389 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
 390 {
 391         bgscan_deinit(wpa_s);
 392         scard_deinit(wpa_s->scard);
 393         wpa_s->scard = NULL;
 394         wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
 395         eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
 396         l2_packet_deinit(wpa_s->l2);
 397         wpa_s->l2 = NULL;
 398         if (wpa_s->l2_br) {
 399                 l2_packet_deinit(wpa_s->l2_br);
 400                 wpa_s->l2_br = NULL;
 401         }
 402
 403         if (wpa_s->ctrl_iface) {
 404                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 405                 wpa_s->ctrl_iface = NULL;
 406         }
 407         if (wpa_s->conf != NULL) {
 408                 struct wpa_ssid *ssid;
 409                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
 410                         wpas_notify_network_removed(wpa_s, ssid);
 411                 wpa_config_free(wpa_s->conf);
 412                 wpa_s->conf = NULL;
 413         }
 414
 415         os_free(wpa_s->confname);
 416         wpa_s->confname = NULL;
 417
 418         wpa_sm_set_eapol(wpa_s->wpa, NULL);
 419         eapol_sm_deinit(wpa_s->eapol);
 420         wpa_s->eapol = NULL;
 421
 422         rsn_preauth_deinit(wpa_s->wpa);
 423
 424 #ifdef CONFIG_TDLS
 425         wpa_tdls_deinit(wpa_s->wpa);
 426 #endif /* CONFIG_TDLS */
 427
 428         pmksa_candidate_free(wpa_s->wpa);
 429         wpa_sm_deinit(wpa_s->wpa);
 430         wpa_s->wpa = NULL;
 431         wpa_blacklist_clear(wpa_s);
 432
 433         wpa_bss_deinit(wpa_s);
 434
 435         wpa_supplicant_cancel_scan(wpa_s);
 436         wpa_supplicant_cancel_auth_timeout(wpa_s);
 437         eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
 438 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
 439         eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
 440                              wpa_s, NULL);
 441 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
 442
 443         wpas_wps_deinit(wpa_s);
 444
 445         wpabuf_free(wpa_s->pending_eapol_rx);
 446         wpa_s->pending_eapol_rx = NULL;
 447
 448 #ifdef CONFIG_IBSS_RSN
 449         ibss_rsn_deinit(wpa_s->ibss_rsn);
 450         wpa_s->ibss_rsn = NULL;
 451 #endif /* CONFIG_IBSS_RSN */
 452
 453         sme_deinit(wpa_s);
 454
 455 #ifdef CONFIG_AP
 456         wpa_supplicant_ap_deinit(wpa_s);
 457 #endif /* CONFIG_AP */
 458
 459 #ifdef CONFIG_P2P
 460         wpas_p2p_deinit(wpa_s);
 461 #endif /* CONFIG_P2P */
 462
 463 #ifdef CONFIG_OFFCHANNEL
 464         offchannel_deinit(wpa_s);
 465 #endif /* CONFIG_OFFCHANNEL */
 466
 467         wpa_supplicant_cancel_sched_scan(wpa_s);
 468
 469         os_free(wpa_s->next_scan_freqs);
 470         wpa_s->next_scan_freqs = NULL;
 471
 472         gas_query_deinit(wpa_s->gas);
 473         wpa_s->gas = NULL;
 474
 475         free_hw_features(wpa_s);
 476 }
 477
 478
 479 /**
 480  * wpa_clear_keys - Clear keys configured for the driver
 481  * @wpa_s: Pointer to wpa_supplicant data
 482  * @addr: Previously used BSSID or %NULL if not available
 483  *
 484  * This function clears the encryption keys that has been previously configured
 485  * for the driver.
 486  */
 487 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
 488 {
 489         if (wpa_s->keys_cleared) {
 490                 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
 491                  * timing issues with keys being cleared just before new keys
 492                  * are set or just after association or something similar. This
 493                  * shows up in group key handshake failing often because of the
 494                  * client not receiving the first encrypted packets correctly.
 495                  * Skipping some of the extra key clearing steps seems to help
 496                  * in completing group key handshake more reliably. */
 497                 wpa_dbg(wpa_s, MSG_DEBUG, "No keys have been configured - "
 498                         "skip key clearing");
 499                 return;
 500         }
 501
 502         /* MLME-DELETEKEYS.request */
 503         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
 504         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
 505         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
 506         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
 507 #ifdef CONFIG_IEEE80211W
 508         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
 509         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
 510 #endif /* CONFIG_IEEE80211W */
 511         if (addr) {
 512                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
 513                                 0);
 514                 /* MLME-SETPROTECTION.request(None) */
 515                 wpa_drv_mlme_setprotection(
 516                         wpa_s, addr,
 517                         MLME_SETPROTECTION_PROTECT_TYPE_NONE,
 518                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 519         }
 520         wpa_s->keys_cleared = 1;
 521 }
 522
 523
 524 /**
 525  * wpa_supplicant_state_txt - Get the connection state name as a text string
 526  * @state: State (wpa_state; WPA_*)
 527  * Returns: The state name as a printable text string
 528  */
 529 const char * wpa_supplicant_state_txt(enum wpa_states state)
 530 {
 531         switch (state) {
 532         case WPA_DISCONNECTED:
 533                 return "DISCONNECTED";
 534         case WPA_INACTIVE:
 535                 return "INACTIVE";
 536         case WPA_INTERFACE_DISABLED:
 537                 return "INTERFACE_DISABLED";
 538         case WPA_SCANNING:
 539                 return "SCANNING";
 540         case WPA_AUTHENTICATING:
 541                 return "AUTHENTICATING";
 542         case WPA_ASSOCIATING:
 543                 return "ASSOCIATING";
 544         case WPA_ASSOCIATED:
 545                 return "ASSOCIATED";
 546         case WPA_4WAY_HANDSHAKE:
 547                 return "4WAY_HANDSHAKE";
 548         case WPA_GROUP_HANDSHAKE:
 549                 return "GROUP_HANDSHAKE";
 550         case WPA_COMPLETED:
 551                 return "COMPLETED";
 552         default:
 553                 return "UNKNOWN";
 554         }
 555 }
 556
 557
 558 #ifdef CONFIG_BGSCAN
 559
 560 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
 561 {
 562         if (wpas_driver_bss_selection(wpa_s))
 563                 return;
 564         if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
 565                 return;
 566
 567         bgscan_deinit(wpa_s);
 568         if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan) {
 569                 if (bgscan_init(wpa_s, wpa_s->current_ssid)) {
 570                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
 571                                 "bgscan");
 572                         /*
 573                          * Live without bgscan; it is only used as a roaming
 574                          * optimization, so the initial connection is not
 575                          * affected.
 576                          */
 577                 } else
 578                         wpa_s->bgscan_ssid = wpa_s->current_ssid;
 579         } else
 580                 wpa_s->bgscan_ssid = NULL;
 581 }
 582
 583
 584 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
 585 {
 586         if (wpa_s->bgscan_ssid != NULL) {
 587                 bgscan_deinit(wpa_s);
 588                 wpa_s->bgscan_ssid = NULL;
 589         }
 590 }
 591
 592 #endif /* CONFIG_BGSCAN */
 593
 594
 595 /**
 596  * wpa_supplicant_set_state - Set current connection state
 597  * @wpa_s: Pointer to wpa_supplicant data
 598  * @state: The new connection state
 599  *
 600  * This function is called whenever the connection state changes, e.g.,
 601  * association is completed for WPA/WPA2 4-Way Handshake is started.
 602  */
 603 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
 604                               enum wpa_states state)
 605 {
 606         enum wpa_states old_state = wpa_s->wpa_state;
 607
 608         wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
 609                 wpa_supplicant_state_txt(wpa_s->wpa_state),
 610                 wpa_supplicant_state_txt(state));
 611
 612         if (state != WPA_SCANNING)
 613                 wpa_supplicant_notify_scanning(wpa_s, 0);
 614
 615         if (state == WPA_COMPLETED && wpa_s->new_connection) {
 616 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 617                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 618                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
 619                         MACSTR " completed %s [id=%d id_str=%s]",
 620                         MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ?
 621                         "(reauth)" : "(auth)",
 622                         ssid ? ssid->id : -1,
 623                         ssid && ssid->id_str ? ssid->id_str : "");
 624 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 625                 wpa_s->new_connection = 0;
 626                 wpa_s->reassociated_connection = 1;
 627                 wpa_drv_set_operstate(wpa_s, 1);
 628 #ifndef IEEE8021X_EAPOL
 629                 wpa_drv_set_supp_port(wpa_s, 1);
 630 #endif /* IEEE8021X_EAPOL */
 631                 wpa_s->after_wps = 0;
 632 #ifdef CONFIG_P2P
 633                 wpas_p2p_completed(wpa_s);
 634 #endif /* CONFIG_P2P */
 635         } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
 636                    state == WPA_ASSOCIATED) {
 637                 wpa_s->new_connection = 1;
 638                 wpa_drv_set_operstate(wpa_s, 0);
 639 #ifndef IEEE8021X_EAPOL
 640                 wpa_drv_set_supp_port(wpa_s, 0);
 641 #endif /* IEEE8021X_EAPOL */
 642         }
 643         wpa_s->wpa_state = state;
 644
 645 #ifdef CONFIG_BGSCAN
 646         if (state == WPA_COMPLETED)
 647                 wpa_supplicant_start_bgscan(wpa_s);
 648         else
 649                 wpa_supplicant_stop_bgscan(wpa_s);
 650 #endif /* CONFIG_BGSCAN */
 651
 652         if (wpa_s->wpa_state != old_state) {
 653                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 654
 655                 if (wpa_s->wpa_state == WPA_COMPLETED ||
 656                     old_state == WPA_COMPLETED)
 657                         wpas_notify_auth_changed(wpa_s);
 658         }
 659 }
 660
 661
 662 void wpa_supplicant_terminate_proc(struct wpa_global *global)
 663 {
 664         int pending = 0;
 665 #ifdef CONFIG_WPS
 666         struct wpa_supplicant *wpa_s = global->ifaces;
 667         while (wpa_s) {
 668                 if (wpas_wps_terminate_pending(wpa_s) == 1)
 669                         pending = 1;
 670                 wpa_s = wpa_s->next;
 671         }
 672 #endif /* CONFIG_WPS */
 673         if (pending)
 674                 return;
 675         eloop_terminate();
 676 }
 677
 678
 679 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
 680 {
 681         struct wpa_global *global = signal_ctx;
 682         struct wpa_supplicant *wpa_s;
 683         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 684                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d "
 685                         "received", sig);
 686         }
 687         wpa_supplicant_terminate_proc(global);
 688 }
 689
 690
 691 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
 692 {
 693         enum wpa_states old_state = wpa_s->wpa_state;
 694
 695         wpa_s->pairwise_cipher = 0;
 696         wpa_s->group_cipher = 0;
 697         wpa_s->mgmt_group_cipher = 0;
 698         wpa_s->key_mgmt = 0;
 699         if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
 700                 wpa_s->wpa_state = WPA_DISCONNECTED;
 701
 702         if (wpa_s->wpa_state != old_state)
 703                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 704 }
 705
 706
 707 /**
 708  * wpa_supplicant_reload_configuration - Reload configuration data
 709  * @wpa_s: Pointer to wpa_supplicant data
 710  * Returns: 0 on success or -1 if configuration parsing failed
 711  *
 712  * This function can be used to request that the configuration data is reloaded
 713  * (e.g., after configuration file change). This function is reloading
 714  * configuration only for one interface, so this may need to be called multiple
 715  * times if %wpa_supplicant is controlling multiple interfaces and all
 716  * interfaces need reconfiguration.
 717  */
 718 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
 719 {
 720         struct wpa_config *conf;
 721         int reconf_ctrl;
 722         int old_ap_scan;
 723
 724         if (wpa_s->confname == NULL)
 725                 return -1;
 726         conf = wpa_config_read(wpa_s->confname);
 727         if (conf == NULL) {
 728                 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
 729                         "file '%s' - exiting", wpa_s->confname);
 730                 return -1;
 731         }
 732         conf->changed_parameters = (unsigned int) -1;
 733
 734         reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
 735                 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
 736                     os_strcmp(conf->ctrl_interface,
 737                               wpa_s->conf->ctrl_interface) != 0);
 738
 739         if (reconf_ctrl && wpa_s->ctrl_iface) {
 740                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 741                 wpa_s->ctrl_iface = NULL;
 742         }
 743
 744         eapol_sm_invalidate_cached_session(wpa_s->eapol);
 745         if (wpa_s->current_ssid) {
 746                 wpa_supplicant_deauthenticate(wpa_s,
 747                                               WLAN_REASON_DEAUTH_LEAVING);
 748         }
 749
 750         /*
 751          * TODO: should notify EAPOL SM about changes in opensc_engine_path,
 752          * pkcs11_engine_path, pkcs11_module_path.
 753          */
 754         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 755                 /*
 756                  * Clear forced success to clear EAP state for next
 757                  * authentication.
 758                  */
 759                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 760         }
 761         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
 762         wpa_sm_set_config(wpa_s->wpa, NULL);
 763         wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
 764         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
 765         rsn_preauth_deinit(wpa_s->wpa);
 766
 767         old_ap_scan = wpa_s->conf->ap_scan;
 768         wpa_config_free(wpa_s->conf);
 769         wpa_s->conf = conf;
 770         if (old_ap_scan != wpa_s->conf->ap_scan)
 771                 wpas_notify_ap_scan_changed(wpa_s);
 772
 773         if (reconf_ctrl)
 774                 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
 775
 776         wpa_supplicant_update_config(wpa_s);
 777
 778         wpa_supplicant_clear_status(wpa_s);
 779         if (wpa_supplicant_enabled_networks(wpa_s->conf)) {
 780                 wpa_s->reassociate = 1;
 781                 wpa_supplicant_req_scan(wpa_s, 0, 0);
 782         }
 783         wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
 784         return 0;
 785 }
 786
 787
 788 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
 789 {
 790         struct wpa_global *global = signal_ctx;
 791         struct wpa_supplicant *wpa_s;
 792         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 793                 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
 794                         sig);
 795                 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
 796                         wpa_supplicant_terminate_proc(global);
 797                 }
 798         }
 799 }
 800
 801
 802 enum wpa_cipher cipher_suite2driver(int cipher)
 803 {
 804         switch (cipher) {
 805         case WPA_CIPHER_NONE:
 806                 return CIPHER_NONE;
 807         case WPA_CIPHER_WEP40:
 808                 return CIPHER_WEP40;
 809         case WPA_CIPHER_WEP104:
 810                 return CIPHER_WEP104;
 811         case WPA_CIPHER_CCMP:
 812                 return CIPHER_CCMP;
 813         case WPA_CIPHER_TKIP:
 814         default:
 815                 return CIPHER_TKIP;
 816         }
 817 }
 818
 819
 820 enum wpa_key_mgmt key_mgmt2driver(int key_mgmt)
 821 {
 822         switch (key_mgmt) {
 823         case WPA_KEY_MGMT_NONE:
 824                 return KEY_MGMT_NONE;
 825         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
 826                 return KEY_MGMT_802_1X_NO_WPA;
 827         case WPA_KEY_MGMT_IEEE8021X:
 828                 return KEY_MGMT_802_1X;
 829         case WPA_KEY_MGMT_WPA_NONE:
 830                 return KEY_MGMT_WPA_NONE;
 831         case WPA_KEY_MGMT_FT_IEEE8021X:
 832                 return KEY_MGMT_FT_802_1X;
 833         case WPA_KEY_MGMT_FT_PSK:
 834                 return KEY_MGMT_FT_PSK;
 835         case WPA_KEY_MGMT_IEEE8021X_SHA256:
 836                 return KEY_MGMT_802_1X_SHA256;
 837         case WPA_KEY_MGMT_PSK_SHA256:
 838                 return KEY_MGMT_PSK_SHA256;
 839         case WPA_KEY_MGMT_WPS:
 840                 return KEY_MGMT_WPS;
 841         case WPA_KEY_MGMT_PSK:
 842         default:
 843                 return KEY_MGMT_PSK;
 844         }
 845 }
 846
 847
 848 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
 849                                          struct wpa_ssid *ssid,
 850                                          struct wpa_ie_data *ie)
 851 {
 852         int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
 853         if (ret) {
 854                 if (ret == -2) {
 855                         wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
 856                                 "from association info");
 857                 }
 858                 return -1;
 859         }
 860
 861         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
 862                 "cipher suites");
 863         if (!(ie->group_cipher & ssid->group_cipher)) {
 864                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
 865                         "cipher 0x%x (mask 0x%x) - reject",
 866                         ie->group_cipher, ssid->group_cipher);
 867                 return -1;
 868         }
 869         if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
 870                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
 871                         "cipher 0x%x (mask 0x%x) - reject",
 872                         ie->pairwise_cipher, ssid->pairwise_cipher);
 873                 return -1;
 874         }
 875         if (!(ie->key_mgmt & ssid->key_mgmt)) {
 876                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
 877                         "management 0x%x (mask 0x%x) - reject",
 878                         ie->key_mgmt, ssid->key_mgmt);
 879                 return -1;
 880         }
 881
 882 #ifdef CONFIG_IEEE80211W
 883         if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
 884             ssid->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED) {
 885                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
 886                         "that does not support management frame protection - "
 887                         "reject");
 888                 return -1;
 889         }
 890 #endif /* CONFIG_IEEE80211W */
 891
 892         return 0;
 893 }
 894
 895
 896 /**
 897  * wpa_supplicant_set_suites - Set authentication and encryption parameters
 898  * @wpa_s: Pointer to wpa_supplicant data
 899  * @bss: Scan results for the selected BSS, or %NULL if not available
 900  * @ssid: Configuration data for the selected network
 901  * @wpa_ie: Buffer for the WPA/RSN IE
 902  * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
 903  * used buffer length in case the functions returns success.
 904  * Returns: 0 on success or -1 on failure
 905  *
 906  * This function is used to configure authentication and encryption parameters
 907  * based on the network configuration and scan result for the selected BSS (if
 908  * available).
 909  */
 910 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
 911                               struct wpa_bss *bss, struct wpa_ssid *ssid,
 912                               u8 *wpa_ie, size_t *wpa_ie_len)
 913 {
 914         struct wpa_ie_data ie;
 915         int sel, proto;
 916         const u8 *bss_wpa, *bss_rsn;
 917
 918         if (bss) {
 919                 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
 920                 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
 921         } else
 922                 bss_wpa = bss_rsn = NULL;
 923
 924         if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
 925             wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
 926             (ie.group_cipher & ssid->group_cipher) &&
 927             (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 928             (ie.key_mgmt & ssid->key_mgmt)) {
 929                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
 930                 proto = WPA_PROTO_RSN;
 931         } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
 932                    wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
 933                    (ie.group_cipher & ssid->group_cipher) &&
 934                    (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 935                    (ie.key_mgmt & ssid->key_mgmt)) {
 936                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
 937                 proto = WPA_PROTO_WPA;
 938         } else if (bss) {
 939                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
 940                 return -1;
 941         } else {
 942                 if (ssid->proto & WPA_PROTO_RSN)
 943                         proto = WPA_PROTO_RSN;
 944                 else
 945                         proto = WPA_PROTO_WPA;
 946                 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
 947                         os_memset(&ie, 0, sizeof(ie));
 948                         ie.group_cipher = ssid->group_cipher;
 949                         ie.pairwise_cipher = ssid->pairwise_cipher;
 950                         ie.key_mgmt = ssid->key_mgmt;
 951 #ifdef CONFIG_IEEE80211W
 952                         ie.mgmt_group_cipher =
 953                                 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
 954                                 WPA_CIPHER_AES_128_CMAC : 0;
 955 #endif /* CONFIG_IEEE80211W */
 956                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
 957                                 "based on configuration");
 958                 } else
 959                         proto = ie.proto;
 960         }
 961
 962         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
 963                 "pairwise %d key_mgmt %d proto %d",
 964                 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
 965 #ifdef CONFIG_IEEE80211W
 966         if (ssid->ieee80211w) {
 967                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
 968                         ie.mgmt_group_cipher);
 969         }
 970 #endif /* CONFIG_IEEE80211W */
 971
 972         wpa_s->wpa_proto = proto;
 973         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
 974         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
 975                          !!(ssid->proto & WPA_PROTO_RSN));
 976
 977         if (bss || !wpa_s->ap_ies_from_associnfo) {
 978                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
 979                                          bss_wpa ? 2 + bss_wpa[1] : 0) ||
 980                     wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
 981                                          bss_rsn ? 2 + bss_rsn[1] : 0))
 982                         return -1;
 983         }
 984
 985         sel = ie.group_cipher & ssid->group_cipher;
 986         if (sel & WPA_CIPHER_CCMP) {
 987                 wpa_s->group_cipher = WPA_CIPHER_CCMP;
 988                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP");
 989         } else if (sel & WPA_CIPHER_TKIP) {
 990                 wpa_s->group_cipher = WPA_CIPHER_TKIP;
 991                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP");
 992         } else if (sel & WPA_CIPHER_WEP104) {
 993                 wpa_s->group_cipher = WPA_CIPHER_WEP104;
 994                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104");
 995         } else if (sel & WPA_CIPHER_WEP40) {
 996                 wpa_s->group_cipher = WPA_CIPHER_WEP40;
 997                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40");
 998         } else {
 999                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1000                         "cipher");
1001                 return -1;
1002         }
1003
1004         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
1005         if (sel & WPA_CIPHER_CCMP) {
1006                 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
1007                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP");
1008         } else if (sel & WPA_CIPHER_TKIP) {
1009                 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
1010                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP");
1011         } else if (sel & WPA_CIPHER_NONE) {
1012                 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1013                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE");
1014         } else {
1015                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1016                         "cipher");
1017                 return -1;
1018         }
1019
1020         sel = ie.key_mgmt & ssid->key_mgmt;
1021         if (0) {
1022 #ifdef CONFIG_IEEE80211R
1023         } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1024                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1025                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1026         } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1027                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1028                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1029 #endif /* CONFIG_IEEE80211R */
1030 #ifdef CONFIG_IEEE80211W
1031         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1032                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1033                 wpa_dbg(wpa_s, MSG_DEBUG,
1034                         "WPA: using KEY_MGMT 802.1X with SHA256");
1035         } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1036                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1037                 wpa_dbg(wpa_s, MSG_DEBUG,
1038                         "WPA: using KEY_MGMT PSK with SHA256");
1039 #endif /* CONFIG_IEEE80211W */
1040         } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1041                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1042                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1043         } else if (sel & WPA_KEY_MGMT_PSK) {
1044                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1045                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1046         } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1047                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1048                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1049         } else {
1050                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1051                         "authenticated key management type");
1052                 return -1;
1053         }
1054
1055         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1056         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1057                          wpa_s->pairwise_cipher);
1058         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1059
1060 #ifdef CONFIG_IEEE80211W
1061         sel = ie.mgmt_group_cipher;
1062         if (ssid->ieee80211w == NO_MGMT_FRAME_PROTECTION ||
1063             !(ie.capabilities & WPA_CAPABILITY_MFPC))
1064                 sel = 0;
1065         if (sel & WPA_CIPHER_AES_128_CMAC) {
1066                 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1067                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1068                         "AES-128-CMAC");
1069         } else {
1070                 wpa_s->mgmt_group_cipher = 0;
1071                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1072         }
1073         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1074                          wpa_s->mgmt_group_cipher);
1075         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, ssid->ieee80211w);
1076 #endif /* CONFIG_IEEE80211W */
1077
1078         if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1079                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1080                 return -1;
1081         }
1082
1083         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
1084                 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
1085 #ifndef CONFIG_NO_PBKDF2
1086                 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1087                     ssid->passphrase) {
1088                         u8 psk[PMK_LEN];
1089                         pbkdf2_sha1(ssid->passphrase, (char *) bss->ssid,
1090                                     bss->ssid_len, 4096, psk, PMK_LEN);
1091                         wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1092                                         psk, PMK_LEN);
1093                         wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1094                 }
1095 #endif /* CONFIG_NO_PBKDF2 */
1096         } else
1097                 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1098
1099         return 0;
1100 }
1101
1102
1103 /**
1104  * wpa_supplicant_associate - Request association
1105  * @wpa_s: Pointer to wpa_supplicant data
1106  * @bss: Scan results for the selected BSS, or %NULL if not available
1107  * @ssid: Configuration data for the selected network
1108  *
1109  * This function is used to request %wpa_supplicant to associate with a BSS.
1110  */
1111 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1112                               struct wpa_bss *bss, struct wpa_ssid *ssid)
1113 {
1114         u8 wpa_ie[200];
1115         size_t wpa_ie_len;
1116         int use_crypt, ret, i, bssid_changed;
1117         int algs = WPA_AUTH_ALG_OPEN;
1118         enum wpa_cipher cipher_pairwise, cipher_group;
1119         struct wpa_driver_associate_params params;
1120         int wep_keys_set = 0;
1121         struct wpa_driver_capa capa;
1122         int assoc_failed = 0;
1123         struct wpa_ssid *old_ssid;
1124
1125 #ifdef CONFIG_IBSS_RSN
1126         ibss_rsn_deinit(wpa_s->ibss_rsn);
1127         wpa_s->ibss_rsn = NULL;
1128 #endif /* CONFIG_IBSS_RSN */
1129
1130         if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1131             ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1132 #ifdef CONFIG_AP
1133                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1134                         wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1135                                 "mode");
1136                         return;
1137                 }
1138                 wpa_supplicant_create_ap(wpa_s, ssid);
1139                 wpa_s->current_bss = bss;
1140 #else /* CONFIG_AP */
1141                 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1142                         "the build");
1143 #endif /* CONFIG_AP */
1144                 return;
1145         }
1146
1147 #ifdef CONFIG_TDLS
1148         if (bss)
1149                 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1150                                 bss->ie_len);
1151 #endif /* CONFIG_TDLS */
1152
1153         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1154             ssid->mode == IEEE80211_MODE_INFRA) {
1155                 sme_authenticate(wpa_s, bss, ssid);
1156                 return;
1157         }
1158
1159         os_memset(&params, 0, sizeof(params));
1160         wpa_s->reassociate = 0;
1161         if (bss && !wpas_driver_bss_selection(wpa_s)) {
1162 #ifdef CONFIG_IEEE80211R
1163                 const u8 *ie, *md = NULL;
1164 #endif /* CONFIG_IEEE80211R */
1165                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1166                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
1167                         wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
1168                 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1169                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1170                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1171                 if (bssid_changed)
1172                         wpas_notify_bssid_changed(wpa_s);
1173 #ifdef CONFIG_IEEE80211R
1174                 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
1175                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1176                         md = ie + 2;
1177                 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1178                 if (md) {
1179                         /* Prepare for the next transition */
1180                         wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1181                 }
1182 #endif /* CONFIG_IEEE80211R */
1183 #ifdef CONFIG_WPS
1184         } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1185                    wpa_s->conf->ap_scan == 2 &&
1186                    (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1187                 /* Use ap_scan==1 style network selection to find the network
1188                  */
1189                 wpa_s->scan_req = 2;
1190                 wpa_s->reassociate = 1;
1191                 wpa_supplicant_req_scan(wpa_s, 0, 0);
1192                 return;
1193 #endif /* CONFIG_WPS */
1194         } else {
1195                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1196                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1197                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1198         }
1199         wpa_supplicant_cancel_sched_scan(wpa_s);
1200         wpa_supplicant_cancel_scan(wpa_s);
1201
1202         /* Starting new association, so clear the possibly used WPA IE from the
1203          * previous association. */
1204         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1205
1206 #ifdef IEEE8021X_EAPOL
1207         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1208                 if (ssid->leap) {
1209                         if (ssid->non_leap == 0)
1210                                 algs = WPA_AUTH_ALG_LEAP;
1211                         else
1212                                 algs |= WPA_AUTH_ALG_LEAP;
1213                 }
1214         }
1215 #endif /* IEEE8021X_EAPOL */
1216         wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1217         if (ssid->auth_alg) {
1218                 algs = ssid->auth_alg;
1219                 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1220                         "0x%x", algs);
1221         }
1222
1223         if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1224                     wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
1225             wpa_key_mgmt_wpa(ssid->key_mgmt)) {
1226                 int try_opportunistic;
1227                 try_opportunistic = ssid->proactive_key_caching &&
1228                         (ssid->proto & WPA_PROTO_RSN);
1229                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1230                                             wpa_s->current_ssid,
1231                                             try_opportunistic) == 0)
1232                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1233                 wpa_ie_len = sizeof(wpa_ie);
1234                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1235                                               wpa_ie, &wpa_ie_len)) {
1236                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1237                                 "key management and encryption suites");
1238                         return;
1239                 }
1240         } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
1241                 wpa_ie_len = sizeof(wpa_ie);
1242                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1243                                               wpa_ie, &wpa_ie_len)) {
1244                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1245                                 "key management and encryption suites (no "
1246                                 "scan results)");
1247                         return;
1248                 }
1249 #ifdef CONFIG_WPS
1250         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
1251                 struct wpabuf *wps_ie;
1252                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
1253                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1254                         wpa_ie_len = wpabuf_len(wps_ie);
1255                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
1256                 } else
1257                         wpa_ie_len = 0;
1258                 wpabuf_free(wps_ie);
1259                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1260                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1261                         params.wps = WPS_MODE_PRIVACY;
1262                 else
1263                         params.wps = WPS_MODE_OPEN;
1264                 wpa_s->wpa_proto = 0;
1265 #endif /* CONFIG_WPS */
1266         } else {
1267                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1268                 wpa_ie_len = 0;
1269                 wpa_s->wpa_proto = 0;
1270         }
1271
1272 #ifdef CONFIG_P2P
1273         if (wpa_s->global->p2p) {
1274                 u8 *pos;
1275                 size_t len;
1276                 int res;
1277                 int p2p_group;
1278                 p2p_group = wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE;
1279                 pos = wpa_ie + wpa_ie_len;
1280                 len = sizeof(wpa_ie) - wpa_ie_len;
1281                 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len, p2p_group);
1282                 if (res >= 0)
1283                         wpa_ie_len += res;
1284         }
1285
1286         wpa_s->cross_connect_disallowed = 0;
1287         if (bss) {
1288                 struct wpabuf *p2p;
1289                 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1290                 if (p2p) {
1291                         wpa_s->cross_connect_disallowed =
1292                                 p2p_get_cross_connect_disallowed(p2p);
1293                         wpabuf_free(p2p);
1294                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1295                                 "connection",
1296                                 wpa_s->cross_connect_disallowed ?
1297                                 "disallows" : "allows");
1298                 }
1299         }
1300 #endif /* CONFIG_P2P */
1301
1302 #ifdef CONFIG_INTERWORKING
1303         if (wpa_s->conf->interworking) {
1304                 u8 *pos = wpa_ie;
1305                 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
1306                         pos += 2 + pos[1];
1307                 os_memmove(pos + 6, pos, wpa_ie_len - (pos - wpa_ie));
1308                 wpa_ie_len += 6;
1309                 *pos++ = WLAN_EID_EXT_CAPAB;
1310                 *pos++ = 4;
1311                 *pos++ = 0x00;
1312                 *pos++ = 0x00;
1313                 *pos++ = 0x00;
1314                 *pos++ = 0x80; /* Bit 31 - Interworking */
1315         }
1316 #endif /* CONFIG_INTERWORKING */
1317
1318         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1319         use_crypt = 1;
1320         cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher);
1321         cipher_group = cipher_suite2driver(wpa_s->group_cipher);
1322         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1323             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1324                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1325                         use_crypt = 0;
1326                 if (wpa_set_wep_keys(wpa_s, ssid)) {
1327                         use_crypt = 1;
1328                         wep_keys_set = 1;
1329                 }
1330         }
1331         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1332                 use_crypt = 0;
1333
1334 #ifdef IEEE8021X_EAPOL
1335         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1336                 if ((ssid->eapol_flags &
1337                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1338                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1339                     !wep_keys_set) {
1340                         use_crypt = 0;
1341                 } else {
1342                         /* Assume that dynamic WEP-104 keys will be used and
1343                          * set cipher suites in order for drivers to expect
1344                          * encryption. */
1345                         cipher_pairwise = cipher_group = CIPHER_WEP104;
1346                 }
1347         }
1348 #endif /* IEEE8021X_EAPOL */
1349
1350         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1351                 /* Set the key before (and later after) association */
1352                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1353         }
1354
1355         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1356         if (bss) {
1357                 params.ssid = bss->ssid;
1358                 params.ssid_len = bss->ssid_len;
1359                 if (!wpas_driver_bss_selection(wpa_s)) {
1360                         params.bssid = bss->bssid;
1361                         params.freq = bss->freq;
1362                 }
1363         } else {
1364                 params.ssid = ssid->ssid;
1365                 params.ssid_len = ssid->ssid_len;
1366         }
1367         if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
1368             params.freq == 0)
1369                 params.freq = ssid->frequency; /* Initial channel for IBSS */
1370         params.wpa_ie = wpa_ie;
1371         params.wpa_ie_len = wpa_ie_len;
1372         params.pairwise_suite = cipher_pairwise;
1373         params.group_suite = cipher_group;
1374         params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1375         params.wpa_proto = wpa_s->wpa_proto;
1376         params.auth_alg = algs;
1377         params.mode = ssid->mode;
1378         for (i = 0; i < NUM_WEP_KEYS; i++) {
1379                 if (ssid->wep_key_len[i])
1380                         params.wep_key[i] = ssid->wep_key[i];
1381                 params.wep_key_len[i] = ssid->wep_key_len[i];
1382         }
1383         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1384
1385         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1386             (params.key_mgmt_suite == KEY_MGMT_PSK ||
1387              params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1388                 params.passphrase = ssid->passphrase;
1389                 if (ssid->psk_set)
1390                         params.psk = ssid->psk;
1391         }
1392
1393         params.drop_unencrypted = use_crypt;
1394
1395 #ifdef CONFIG_IEEE80211W
1396         params.mgmt_frame_protection = ssid->ieee80211w;
1397         if (ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION && bss) {
1398                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1399                 struct wpa_ie_data ie;
1400                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1401                     ie.capabilities &
1402                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1403                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1404                                 "MFP: require MFP");
1405                         params.mgmt_frame_protection =
1406                                 MGMT_FRAME_PROTECTION_REQUIRED;
1407                 }
1408         }
1409 #endif /* CONFIG_IEEE80211W */
1410
1411         params.p2p = ssid->p2p_group;
1412
1413         if (wpa_s->parent->set_sta_uapsd)
1414                 params.uapsd = wpa_s->parent->sta_uapsd;
1415         else
1416                 params.uapsd = -1;
1417
1418         ret = wpa_drv_associate(wpa_s, &params);
1419         if (ret < 0) {
1420                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1421                         "failed");
1422                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1423                         /*
1424                          * The driver is known to mean what is saying, so we
1425                          * can stop right here; the association will not
1426                          * succeed.
1427                          */
1428                         wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
1429                         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1430                         return;
1431                 }
1432                 /* try to continue anyway; new association will be tried again
1433                  * after timeout */
1434                 assoc_failed = 1;
1435         }
1436
1437         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1438                 /* Set the key after the association just in case association
1439                  * cleared the previously configured key. */
1440                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1441                 /* No need to timeout authentication since there is no key
1442                  * management. */
1443                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1444                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1445 #ifdef CONFIG_IBSS_RSN
1446         } else if (ssid->mode == WPAS_MODE_IBSS &&
1447                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1448                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1449                 /*
1450                  * RSN IBSS authentication is per-STA and we can disable the
1451                  * per-BSSID authentication.
1452                  */
1453                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1454 #endif /* CONFIG_IBSS_RSN */
1455         } else {
1456                 /* Timeout for IEEE 802.11 authentication and association */
1457                 int timeout = 60;
1458
1459                 if (assoc_failed) {
1460                         /* give IBSS a bit more time */
1461                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
1462                 } else if (wpa_s->conf->ap_scan == 1) {
1463                         /* give IBSS a bit more time */
1464                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
1465                 }
1466                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1467         }
1468
1469         if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1470             capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1471                 /* Set static WEP keys again */
1472                 wpa_set_wep_keys(wpa_s, ssid);
1473         }
1474
1475         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1476                 /*
1477                  * Do not allow EAP session resumption between different
1478                  * network configurations.
1479                  */
1480                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1481         }
1482         old_ssid = wpa_s->current_ssid;
1483         wpa_s->current_ssid = ssid;
1484         wpa_s->current_bss = bss;
1485         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1486         wpa_supplicant_initiate_eapol(wpa_s);
1487         if (old_ssid != wpa_s->current_ssid)
1488                 wpas_notify_network_changed(wpa_s);
1489 }
1490
1491
1492 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1493                                             const u8 *addr)
1494 {
1495         struct wpa_ssid *old_ssid;
1496
1497         wpa_clear_keys(wpa_s, addr);
1498         wpa_supplicant_mark_disassoc(wpa_s);
1499         old_ssid = wpa_s->current_ssid;
1500         wpa_s->current_ssid = NULL;
1501         wpa_s->current_bss = NULL;
1502         wpa_sm_set_config(wpa_s->wpa, NULL);
1503         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1504         if (old_ssid != wpa_s->current_ssid)
1505                 wpas_notify_network_changed(wpa_s);
1506         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1507 }
1508
1509
1510 /**
1511  * wpa_supplicant_disassociate - Disassociate the current connection
1512  * @wpa_s: Pointer to wpa_supplicant data
1513  * @reason_code: IEEE 802.11 reason code for the disassociate frame
1514  *
1515  * This function is used to request %wpa_supplicant to disassociate with the
1516  * current AP.
1517  */
1518 void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1519                                  int reason_code)
1520 {
1521         u8 *addr = NULL;
1522
1523         if (!is_zero_ether_addr(wpa_s->bssid)) {
1524                 wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1525                 addr = wpa_s->bssid;
1526         }
1527
1528         wpa_supplicant_clear_connection(wpa_s, addr);
1529 }
1530
1531
1532 /**
1533  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1534  * @wpa_s: Pointer to wpa_supplicant data
1535  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1536  *
1537  * This function is used to request %wpa_supplicant to deauthenticate from the
1538  * current AP.
1539  */
1540 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1541                                    int reason_code)
1542 {
1543         u8 *addr = NULL;
1544
1545         if (!is_zero_ether_addr(wpa_s->bssid)) {
1546                 wpa_drv_deauthenticate(wpa_s, wpa_s->bssid, reason_code);
1547                 addr = wpa_s->bssid;
1548         }
1549
1550         wpa_supplicant_clear_connection(wpa_s, addr);
1551 }
1552
1553
1554 /**
1555  * wpa_supplicant_enable_network - Mark a configured network as enabled
1556  * @wpa_s: wpa_supplicant structure for a network interface
1557  * @ssid: wpa_ssid structure for a configured network or %NULL
1558  *
1559  * Enables the specified network or all networks if no network specified.
1560  */
1561 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
1562                                    struct wpa_ssid *ssid)
1563 {
1564         struct wpa_ssid *other_ssid;
1565         int was_disabled;
1566
1567         if (ssid == NULL) {
1568                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1569                      other_ssid = other_ssid->next) {
1570                         if (other_ssid->disabled == 2)
1571                                 continue; /* do not change persistent P2P group
1572                                            * data */
1573                         if (other_ssid == wpa_s->current_ssid &&
1574                             other_ssid->disabled)
1575                                 wpa_s->reassociate = 1;
1576
1577                         was_disabled = other_ssid->disabled;
1578
1579                         other_ssid->disabled = 0;
1580
1581                         if (was_disabled != other_ssid->disabled)
1582                                 wpas_notify_network_enabled_changed(
1583                                         wpa_s, other_ssid);
1584                 }
1585                 if (wpa_s->reassociate)
1586                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1587         } else if (ssid->disabled && ssid->disabled != 2) {
1588                 if (wpa_s->current_ssid == NULL) {
1589                         /*
1590                          * Try to reassociate since there is no current
1591                          * configuration and a new network was made available.
1592                          */
1593                         wpa_s->reassociate = 1;
1594                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1595                 }
1596
1597                 was_disabled = ssid->disabled;
1598
1599                 ssid->disabled = 0;
1600
1601                 if (was_disabled != ssid->disabled)
1602                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1603         }
1604 }
1605
1606
1607 /**
1608  * wpa_supplicant_disable_network - Mark a configured network as disabled
1609  * @wpa_s: wpa_supplicant structure for a network interface
1610  * @ssid: wpa_ssid structure for a configured network or %NULL
1611  *
1612  * Disables the specified network or all networks if no network specified.
1613  */
1614 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
1615                                     struct wpa_ssid *ssid)
1616 {
1617         struct wpa_ssid *other_ssid;
1618         int was_disabled;
1619
1620         if (ssid == NULL) {
1621                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1622                      other_ssid = other_ssid->next) {
1623                         was_disabled = other_ssid->disabled;
1624                         if (was_disabled == 2)
1625                                 continue; /* do not change persistent P2P group
1626                                            * data */
1627
1628                         other_ssid->disabled = 1;
1629
1630                         if (was_disabled != other_ssid->disabled)
1631                                 wpas_notify_network_enabled_changed(
1632                                         wpa_s, other_ssid);
1633                 }
1634                 if (wpa_s->current_ssid)
1635                         wpa_supplicant_disassociate(
1636                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1637         } else if (ssid->disabled != 2) {
1638                 if (ssid == wpa_s->current_ssid)
1639                         wpa_supplicant_disassociate(
1640                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1641
1642                 was_disabled = ssid->disabled;
1643
1644                 ssid->disabled = 1;
1645
1646                 if (was_disabled != ssid->disabled)
1647                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1648         }
1649 }
1650
1651
1652 /**
1653  * wpa_supplicant_select_network - Attempt association with a network
1654  * @wpa_s: wpa_supplicant structure for a network interface
1655  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
1656  */
1657 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
1658                                    struct wpa_ssid *ssid)
1659 {
1660
1661         struct wpa_ssid *other_ssid;
1662
1663         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid)
1664                 wpa_supplicant_disassociate(
1665                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1666
1667         /*
1668          * Mark all other networks disabled or mark all networks enabled if no
1669          * network specified.
1670          */
1671         for (other_ssid = wpa_s->conf->ssid; other_ssid;
1672              other_ssid = other_ssid->next) {
1673                 int was_disabled = other_ssid->disabled;
1674                 if (was_disabled == 2)
1675                         continue; /* do not change persistent P2P group data */
1676
1677                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
1678
1679                 if (was_disabled != other_ssid->disabled)
1680                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
1681         }
1682
1683         if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
1684                 /* We are already associated with the selected network */
1685                 wpa_printf(MSG_DEBUG, "Already associated with the "
1686                            "selected network - do nothing");
1687                 return;
1688         }
1689
1690         wpa_s->connect_without_scan = NULL;
1691         wpa_s->disconnected = 0;
1692         wpa_s->reassociate = 1;
1693         wpa_supplicant_req_scan(wpa_s, 0, 0);
1694
1695         if (ssid)
1696                 wpas_notify_network_selected(wpa_s, ssid);
1697 }
1698
1699
1700 /**
1701  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
1702  * @wpa_s: wpa_supplicant structure for a network interface
1703  * @ap_scan: AP scan mode
1704  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
1705  *
1706  */
1707 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
1708 {
1709
1710         int old_ap_scan;
1711
1712         if (ap_scan < 0 || ap_scan > 2)
1713                 return -1;
1714
1715 #ifdef ANDROID
1716         if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
1717             wpa_s->wpa_state >= WPA_ASSOCIATING &&
1718             wpa_s->wpa_state < WPA_COMPLETED) {
1719                 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
1720                            "associating", wpa_s->conf->ap_scan, ap_scan);
1721                 return 0;
1722         }
1723 #endif /* ANDROID */
1724
1725         old_ap_scan = wpa_s->conf->ap_scan;
1726         wpa_s->conf->ap_scan = ap_scan;
1727
1728         if (old_ap_scan != wpa_s->conf->ap_scan)
1729                 wpas_notify_ap_scan_changed(wpa_s);
1730
1731         return 0;
1732 }
1733
1734
1735 /**
1736  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
1737  * @wpa_s: wpa_supplicant structure for a network interface
1738  * @expire_age: Expiration age in seconds
1739  * Returns: 0 if succeed or -1 if expire_age has an invalid value
1740  *
1741  */
1742 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
1743                                           unsigned int bss_expire_age)
1744 {
1745         if (bss_expire_age < 10) {
1746                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
1747                         bss_expire_age);
1748                 return -1;
1749         }
1750         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
1751                 bss_expire_age);
1752         wpa_s->conf->bss_expiration_age = bss_expire_age;
1753
1754         return 0;
1755 }
1756
1757
1758 /**
1759  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
1760  * @wpa_s: wpa_supplicant structure for a network interface
1761  * @expire_count: number of scans after which an unseen BSS is reclaimed
1762  * Returns: 0 if succeed or -1 if expire_count has an invalid value
1763  *
1764  */
1765 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
1766                                             unsigned int bss_expire_count)
1767 {
1768         if (bss_expire_count < 1) {
1769                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
1770                         bss_expire_count);
1771                 return -1;
1772         }
1773         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
1774                 bss_expire_count);
1775         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
1776
1777         return 0;
1778 }
1779
1780
1781 /**
1782  * wpa_supplicant_set_debug_params - Set global debug params
1783  * @global: wpa_global structure
1784  * @debug_level: debug level
1785  * @debug_timestamp: determines if show timestamp in debug data
1786  * @debug_show_keys: determines if show keys in debug data
1787  * Returns: 0 if succeed or -1 if debug_level has wrong value
1788  */
1789 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
1790                                     int debug_timestamp, int debug_show_keys)
1791 {
1792
1793         int old_level, old_timestamp, old_show_keys;
1794
1795         /* check for allowed debuglevels */
1796         if (debug_level != MSG_EXCESSIVE &&
1797             debug_level != MSG_MSGDUMP &&
1798             debug_level != MSG_DEBUG &&
1799             debug_level != MSG_INFO &&
1800             debug_level != MSG_WARNING &&
1801             debug_level != MSG_ERROR)
1802                 return -1;
1803
1804         old_level = wpa_debug_level;
1805         old_timestamp = wpa_debug_timestamp;
1806         old_show_keys = wpa_debug_show_keys;
1807
1808         wpa_debug_level = debug_level;
1809         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
1810         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
1811
1812         if (wpa_debug_level != old_level)
1813                 wpas_notify_debug_level_changed(global);
1814         if (wpa_debug_timestamp != old_timestamp)
1815                 wpas_notify_debug_timestamp_changed(global);
1816         if (wpa_debug_show_keys != old_show_keys)
1817                 wpas_notify_debug_show_keys_changed(global);
1818
1819         return 0;
1820 }
1821
1822
1823 /**
1824  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
1825  * @wpa_s: Pointer to wpa_supplicant data
1826  * Returns: A pointer to the current network structure or %NULL on failure
1827  */
1828 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
1829 {
1830         struct wpa_ssid *entry;
1831         u8 ssid[MAX_SSID_LEN];
1832         int res;
1833         size_t ssid_len;
1834         u8 bssid[ETH_ALEN];
1835         int wired;
1836
1837         res = wpa_drv_get_ssid(wpa_s, ssid);
1838         if (res < 0) {
1839                 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
1840                         "driver");
1841                 return NULL;
1842         }
1843         ssid_len = res;
1844
1845         if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
1846                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
1847                         "driver");
1848                 return NULL;
1849         }
1850
1851         wired = wpa_s->conf->ap_scan == 0 &&
1852                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
1853
1854         entry = wpa_s->conf->ssid;
1855         while (entry) {
1856                 if (!entry->disabled &&
1857                     ((ssid_len == entry->ssid_len &&
1858                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
1859                     (!entry->bssid_set ||
1860                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1861                         return entry;
1862 #ifdef CONFIG_WPS
1863                 if (!entry->disabled &&
1864                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
1865                     (entry->ssid == NULL || entry->ssid_len == 0) &&
1866                     (!entry->bssid_set ||
1867                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1868                         return entry;
1869 #endif /* CONFIG_WPS */
1870
1871                 if (!entry->disabled && entry->bssid_set &&
1872                     entry->ssid_len == 0 &&
1873                     os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
1874                         return entry;
1875
1876                 entry = entry->next;
1877         }
1878
1879         return NULL;
1880 }
1881
1882
1883 static int select_driver(struct wpa_supplicant *wpa_s, int i)
1884 {
1885         struct wpa_global *global = wpa_s->global;
1886
1887         if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
1888                 global->drv_priv[i] = wpa_drivers[i]->global_init();
1889                 if (global->drv_priv[i] == NULL) {
1890                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
1891                                    "'%s'", wpa_drivers[i]->name);
1892                         return -1;
1893                 }
1894         }
1895
1896         wpa_s->driver = wpa_drivers[i];
1897         wpa_s->global_drv_priv = global->drv_priv[i];
1898
1899         return 0;
1900 }
1901
1902
1903 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
1904                                      const char *name)
1905 {
1906         int i;
1907         size_t len;
1908         const char *pos, *driver = name;
1909
1910         if (wpa_s == NULL)
1911                 return -1;
1912
1913         if (wpa_drivers[0] == NULL) {
1914                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
1915                         "wpa_supplicant");
1916                 return -1;
1917         }
1918
1919         if (name == NULL) {
1920                 /* default to first driver in the list */
1921                 return select_driver(wpa_s, 0);
1922         }
1923
1924         do {
1925                 pos = os_strchr(driver, ',');
1926                 if (pos)
1927                         len = pos - driver;
1928                 else
1929                         len = os_strlen(driver);
1930
1931                 for (i = 0; wpa_drivers[i]; i++) {
1932                         if (os_strlen(wpa_drivers[i]->name) == len &&
1933                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
1934                             0)
1935                                 return select_driver(wpa_s, i);
1936                 }
1937
1938                 driver = pos + 1;
1939         } while (pos);
1940
1941         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
1942         return -1;
1943 }
1944
1945
1946 /**
1947  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
1948  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
1949  *      with struct wpa_driver_ops::init()
1950  * @src_addr: Source address of the EAPOL frame
1951  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
1952  * @len: Length of the EAPOL data
1953  *
1954  * This function is called for each received EAPOL frame. Most driver
1955  * interfaces rely on more generic OS mechanism for receiving frames through
1956  * l2_packet, but if such a mechanism is not available, the driver wrapper may
1957  * take care of received EAPOL frames and deliver them to the core supplicant
1958  * code by calling this function.
1959  */
1960 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1961                              const u8 *buf, size_t len)
1962 {
1963         struct wpa_supplicant *wpa_s = ctx;
1964
1965         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
1966         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
1967
1968         if (wpa_s->wpa_state < WPA_ASSOCIATED) {
1969                 /*
1970                  * There is possible race condition between receiving the
1971                  * association event and the EAPOL frame since they are coming
1972                  * through different paths from the driver. In order to avoid
1973                  * issues in trying to process the EAPOL frame before receiving
1974                  * association information, lets queue it for processing until
1975                  * the association event is received.
1976                  */
1977                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
1978                         "of received EAPOL frame");
1979                 wpabuf_free(wpa_s->pending_eapol_rx);
1980                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
1981                 if (wpa_s->pending_eapol_rx) {
1982                         os_get_time(&wpa_s->pending_eapol_rx_time);
1983                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
1984                                   ETH_ALEN);
1985                 }
1986                 return;
1987         }
1988
1989 #ifdef CONFIG_AP
1990         if (wpa_s->ap_iface) {
1991                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
1992                 return;
1993         }
1994 #endif /* CONFIG_AP */
1995
1996         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
1997                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
1998                         "no key management is configured");
1999                 return;
2000         }
2001
2002         if (wpa_s->eapol_received == 0 &&
2003             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2004              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2005              wpa_s->wpa_state != WPA_COMPLETED) &&
2006             (wpa_s->current_ssid == NULL ||
2007              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2008                 /* Timeout for completing IEEE 802.1X and WPA authentication */
2009                 wpa_supplicant_req_auth_timeout(
2010                         wpa_s,
2011                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2012                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2013                          wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2014                         70 : 10, 0);
2015         }
2016         wpa_s->eapol_received++;
2017
2018         if (wpa_s->countermeasures) {
2019                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2020                         "EAPOL packet");
2021                 return;
2022         }
2023
2024 #ifdef CONFIG_IBSS_RSN
2025         if (wpa_s->current_ssid &&
2026             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2027                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2028                 return;
2029         }
2030 #endif /* CONFIG_IBSS_RSN */
2031
2032         /* Source address of the incoming EAPOL frame could be compared to the
2033          * current BSSID. However, it is possible that a centralized
2034          * Authenticator could be using another MAC address than the BSSID of
2035          * an AP, so just allow any address to be used for now. The replies are
2036          * still sent to the current BSSID (if available), though. */
2037
2038         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2039         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2040             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2041                 return;
2042         wpa_drv_poll(wpa_s);
2043         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2044                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2045         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2046                 /*
2047                  * Set portValid = TRUE here since we are going to skip 4-way
2048                  * handshake processing which would normally set portValid. We
2049                  * need this to allow the EAPOL state machines to be completed
2050                  * without going through EAPOL-Key handshake.
2051                  */
2052                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2053         }
2054 }
2055
2056
2057 /**
2058  * wpa_supplicant_driver_init - Initialize driver interface parameters
2059  * @wpa_s: Pointer to wpa_supplicant data
2060  * Returns: 0 on success, -1 on failure
2061  *
2062  * This function is called to initialize driver interface parameters.
2063  * wpa_drv_init() must have been called before this function to initialize the
2064  * driver interface.
2065  */
2066 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2067 {
2068         static int interface_count = 0;
2069
2070         if (wpa_s->driver->send_eapol) {
2071                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2072                 if (addr)
2073                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2074         } else if (!(wpa_s->drv_flags &
2075                      WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
2076                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2077                                            wpa_drv_get_mac_addr(wpa_s),
2078                                            ETH_P_EAPOL,
2079                                            wpa_supplicant_rx_eapol, wpa_s, 0);
2080                 if (wpa_s->l2 == NULL)
2081                         return -1;
2082         } else {
2083                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2084                 if (addr)
2085                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2086         }
2087
2088         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2089                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2090                 return -1;
2091         }
2092
2093         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2094                 MAC2STR(wpa_s->own_addr));
2095
2096         if (wpa_s->bridge_ifname[0]) {
2097                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2098                         "interface '%s'", wpa_s->bridge_ifname);
2099                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2100                                               wpa_s->own_addr,
2101                                               ETH_P_EAPOL,
2102                                               wpa_supplicant_rx_eapol, wpa_s,
2103                                               0);
2104                 if (wpa_s->l2_br == NULL) {
2105                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2106                                 "connection for the bridge interface '%s'",
2107                                 wpa_s->bridge_ifname);
2108                         return -1;
2109                 }
2110         }
2111
2112         wpa_clear_keys(wpa_s, NULL);
2113
2114         /* Make sure that TKIP countermeasures are not left enabled (could
2115          * happen if wpa_supplicant is killed during countermeasures. */
2116         wpa_drv_set_countermeasures(wpa_s, 0);
2117
2118         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2119         wpa_drv_flush_pmkid(wpa_s);
2120
2121         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2122         if (wpa_supplicant_enabled_networks(wpa_s->conf)) {
2123                 if (wpa_supplicant_delayed_sched_scan(wpa_s, interface_count,
2124                                                       100000))
2125                         wpa_supplicant_req_scan(wpa_s, interface_count,
2126                                                 100000);
2127                 interface_count++;
2128         } else
2129                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2130
2131         return 0;
2132 }
2133
2134
2135 static int wpa_supplicant_daemon(const char *pid_file)
2136 {
2137         wpa_printf(MSG_DEBUG, "Daemonize..");
2138         return os_daemonize(pid_file);
2139 }
2140
2141
2142 static struct wpa_supplicant * wpa_supplicant_alloc(void)
2143 {
2144         struct wpa_supplicant *wpa_s;
2145
2146         wpa_s = os_zalloc(sizeof(*wpa_s));
2147         if (wpa_s == NULL)
2148                 return NULL;
2149         wpa_s->scan_req = 1;
2150         wpa_s->scan_interval = 5;
2151         wpa_s->new_connection = 1;
2152         wpa_s->parent = wpa_s;
2153         wpa_s->sched_scanning = 0;
2154
2155         return wpa_s;
2156 }
2157
2158
2159 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
2160                                      struct wpa_interface *iface)
2161 {
2162         const char *ifname, *driver;
2163         struct wpa_driver_capa capa;
2164
2165         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
2166                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
2167                    iface->confname ? iface->confname : "N/A",
2168                    iface->driver ? iface->driver : "default",
2169                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
2170                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
2171
2172         if (iface->confname) {
2173 #ifdef CONFIG_BACKEND_FILE
2174                 wpa_s->confname = os_rel2abs_path(iface->confname);
2175                 if (wpa_s->confname == NULL) {
2176                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
2177                                    "for configuration file '%s'.",
2178                                    iface->confname);
2179                         return -1;
2180                 }
2181                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
2182                            iface->confname, wpa_s->confname);
2183 #else /* CONFIG_BACKEND_FILE */
2184                 wpa_s->confname = os_strdup(iface->confname);
2185 #endif /* CONFIG_BACKEND_FILE */
2186                 wpa_s->conf = wpa_config_read(wpa_s->confname);
2187                 if (wpa_s->conf == NULL) {
2188                         wpa_printf(MSG_ERROR, "Failed to read or parse "
2189                                    "configuration '%s'.", wpa_s->confname);
2190                         return -1;
2191                 }
2192
2193                 /*
2194                  * Override ctrl_interface and driver_param if set on command
2195                  * line.
2196                  */
2197                 if (iface->ctrl_interface) {
2198                         os_free(wpa_s->conf->ctrl_interface);
2199                         wpa_s->conf->ctrl_interface =
2200                                 os_strdup(iface->ctrl_interface);
2201                 }
2202
2203                 if (iface->driver_param) {
2204                         os_free(wpa_s->conf->driver_param);
2205                         wpa_s->conf->driver_param =
2206                                 os_strdup(iface->driver_param);
2207                 }
2208         } else
2209                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
2210                                                      iface->driver_param);
2211
2212         if (wpa_s->conf == NULL) {
2213                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
2214                 return -1;
2215         }
2216
2217         if (iface->ifname == NULL) {
2218                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
2219                 return -1;
2220         }
2221         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
2222                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
2223                            iface->ifname);
2224                 return -1;
2225         }
2226         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
2227
2228         if (iface->bridge_ifname) {
2229                 if (os_strlen(iface->bridge_ifname) >=
2230                     sizeof(wpa_s->bridge_ifname)) {
2231                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
2232                                    "name '%s'.", iface->bridge_ifname);
2233                         return -1;
2234                 }
2235                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
2236                            sizeof(wpa_s->bridge_ifname));
2237         }
2238
2239         /* RSNA Supplicant Key Management - INITIALIZE */
2240         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
2241         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
2242
2243         /* Initialize driver interface and register driver event handler before
2244          * L2 receive handler so that association events are processed before
2245          * EAPOL-Key packets if both become available for the same select()
2246          * call. */
2247         driver = iface->driver;
2248 next_driver:
2249         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
2250                 return -1;
2251
2252         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
2253         if (wpa_s->drv_priv == NULL) {
2254                 const char *pos;
2255                 pos = driver ? os_strchr(driver, ',') : NULL;
2256                 if (pos) {
2257                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
2258                                 "driver interface - try next driver wrapper");
2259                         driver = pos + 1;
2260                         goto next_driver;
2261                 }
2262                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
2263                         "interface");
2264                 return -1;
2265         }
2266         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
2267                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
2268                         "driver_param '%s'", wpa_s->conf->driver_param);
2269                 return -1;
2270         }
2271
2272         ifname = wpa_drv_get_ifname(wpa_s);
2273         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
2274                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
2275                         "interface name with '%s'", ifname);
2276                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2277         }
2278
2279         if (wpa_supplicant_init_wpa(wpa_s) < 0)
2280                 return -1;
2281
2282         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
2283                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
2284                           NULL);
2285         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
2286
2287         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
2288             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
2289                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
2290                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2291                         "dot11RSNAConfigPMKLifetime");
2292                 return -1;
2293         }
2294
2295         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
2296             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
2297                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
2298                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2299                         "dot11RSNAConfigPMKReauthThreshold");
2300                 return -1;
2301         }
2302
2303         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
2304             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
2305                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
2306                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2307                         "dot11RSNAConfigSATimeout");
2308                 return -1;
2309         }
2310
2311         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
2312                                                       &wpa_s->hw.num_modes,
2313                                                       &wpa_s->hw.flags);
2314
2315         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
2316                 wpa_s->drv_capa_known = 1;
2317                 wpa_s->drv_flags = capa.flags;
2318                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
2319                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
2320                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
2321                 wpa_s->max_match_sets = capa.max_match_sets;
2322                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
2323                 wpa_s->max_stations = capa.max_stations;
2324         }
2325         if (wpa_s->max_remain_on_chan == 0)
2326                 wpa_s->max_remain_on_chan = 1000;
2327
2328         if (wpa_supplicant_driver_init(wpa_s) < 0)
2329                 return -1;
2330
2331 #ifdef CONFIG_TDLS
2332         if (wpa_tdls_init(wpa_s->wpa))
2333                 return -1;
2334 #endif /* CONFIG_TDLS */
2335
2336         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
2337             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
2338                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
2339                 return -1;
2340         }
2341
2342         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2343
2344         if (wpas_wps_init(wpa_s))
2345                 return -1;
2346
2347         if (wpa_supplicant_init_eapol(wpa_s) < 0)
2348                 return -1;
2349         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2350
2351         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
2352         if (wpa_s->ctrl_iface == NULL) {
2353                 wpa_printf(MSG_ERROR,
2354                            "Failed to initialize control interface '%s'.\n"
2355                            "You may have another wpa_supplicant process "
2356                            "already running or the file was\n"
2357                            "left by an unclean termination of wpa_supplicant "
2358                            "in which case you will need\n"
2359                            "to manually remove this file before starting "
2360                            "wpa_supplicant again.\n",
2361                            wpa_s->conf->ctrl_interface);
2362                 return -1;
2363         }
2364
2365         wpa_s->gas = gas_query_init(wpa_s);
2366         if (wpa_s->gas == NULL) {
2367                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
2368                 return -1;
2369         }
2370
2371 #ifdef CONFIG_P2P
2372         if (wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
2373                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
2374                 return -1;
2375         }
2376 #endif /* CONFIG_P2P */
2377
2378         if (wpa_bss_init(wpa_s) < 0)
2379                 return -1;
2380
2381         return 0;
2382 }
2383
2384
2385 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
2386                                         int notify)
2387 {
2388         if (wpa_s->drv_priv) {
2389                 wpa_supplicant_deauthenticate(wpa_s,
2390                                               WLAN_REASON_DEAUTH_LEAVING);
2391
2392                 wpa_drv_set_countermeasures(wpa_s, 0);
2393                 wpa_clear_keys(wpa_s, NULL);
2394         }
2395
2396         wpa_supplicant_cleanup(wpa_s);
2397
2398         if (notify)
2399                 wpas_notify_iface_removed(wpa_s);
2400
2401         if (wpa_s->drv_priv)
2402                 wpa_drv_deinit(wpa_s);
2403 }
2404
2405
2406 /**
2407  * wpa_supplicant_add_iface - Add a new network interface
2408  * @global: Pointer to global data from wpa_supplicant_init()
2409  * @iface: Interface configuration options
2410  * Returns: Pointer to the created interface or %NULL on failure
2411  *
2412  * This function is used to add new network interfaces for %wpa_supplicant.
2413  * This can be called before wpa_supplicant_run() to add interfaces before the
2414  * main event loop has been started. In addition, new interfaces can be added
2415  * dynamically while %wpa_supplicant is already running. This could happen,
2416  * e.g., when a hotplug network adapter is inserted.
2417  */
2418 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
2419                                                  struct wpa_interface *iface)
2420 {
2421         struct wpa_supplicant *wpa_s;
2422         struct wpa_interface t_iface;
2423         struct wpa_ssid *ssid;
2424
2425         if (global == NULL || iface == NULL)
2426                 return NULL;
2427
2428         wpa_s = wpa_supplicant_alloc();
2429         if (wpa_s == NULL)
2430                 return NULL;
2431
2432         wpa_s->global = global;
2433
2434         t_iface = *iface;
2435         if (global->params.override_driver) {
2436                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
2437                            "('%s' -> '%s')",
2438                            iface->driver, global->params.override_driver);
2439                 t_iface.driver = global->params.override_driver;
2440         }
2441         if (global->params.override_ctrl_interface) {
2442                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
2443                            "ctrl_interface ('%s' -> '%s')",
2444                            iface->ctrl_interface,
2445                            global->params.override_ctrl_interface);
2446                 t_iface.ctrl_interface =
2447                         global->params.override_ctrl_interface;
2448         }
2449         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
2450                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
2451                            iface->ifname);
2452                 wpa_supplicant_deinit_iface(wpa_s, 0);
2453                 os_free(wpa_s);
2454                 return NULL;
2455         }
2456
2457         /* Notify the control interfaces about new iface */
2458         if (wpas_notify_iface_added(wpa_s)) {
2459                 wpa_supplicant_deinit_iface(wpa_s, 1);
2460                 os_free(wpa_s);
2461                 return NULL;
2462         }
2463
2464         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2465                 wpas_notify_network_added(wpa_s, ssid);
2466
2467         wpa_s->next = global->ifaces;
2468         global->ifaces = wpa_s;
2469
2470         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
2471
2472         return wpa_s;
2473 }
2474
2475
2476 /**
2477  * wpa_supplicant_remove_iface - Remove a network interface
2478  * @global: Pointer to global data from wpa_supplicant_init()
2479  * @wpa_s: Pointer to the network interface to be removed
2480  * Returns: 0 if interface was removed, -1 if interface was not found
2481  *
2482  * This function can be used to dynamically remove network interfaces from
2483  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
2484  * addition, this function is used to remove all remaining interfaces when
2485  * %wpa_supplicant is terminated.
2486  */
2487 int wpa_supplicant_remove_iface(struct wpa_global *global,
2488                                 struct wpa_supplicant *wpa_s)
2489 {
2490         struct wpa_supplicant *prev;
2491
2492         /* Remove interface from the global list of interfaces */
2493         prev = global->ifaces;
2494         if (prev == wpa_s) {
2495                 global->ifaces = wpa_s->next;
2496         } else {
2497                 while (prev && prev->next != wpa_s)
2498                         prev = prev->next;
2499                 if (prev == NULL)
2500                         return -1;
2501                 prev->next = wpa_s->next;
2502         }
2503
2504         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
2505
2506         if (global->p2p_group_formation == wpa_s)
2507                 global->p2p_group_formation = NULL;
2508         wpa_supplicant_deinit_iface(wpa_s, 1);
2509         os_free(wpa_s);
2510
2511         return 0;
2512 }
2513
2514
2515 /**
2516  * wpa_supplicant_get_eap_mode - Get the current EAP mode
2517  * @wpa_s: Pointer to the network interface
2518  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
2519  */
2520 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
2521 {
2522         const char *eapol_method;
2523
2524         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
2525             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2526                 return "NO-EAP";
2527         }
2528
2529         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
2530         if (eapol_method == NULL)
2531                 return "UNKNOWN-EAP";
2532
2533         return eapol_method;
2534 }
2535
2536
2537 /**
2538  * wpa_supplicant_get_iface - Get a new network interface
2539  * @global: Pointer to global data from wpa_supplicant_init()
2540  * @ifname: Interface name
2541  * Returns: Pointer to the interface or %NULL if not found
2542  */
2543 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
2544                                                  const char *ifname)
2545 {
2546         struct wpa_supplicant *wpa_s;
2547
2548         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
2549                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
2550                         return wpa_s;
2551         }
2552         return NULL;
2553 }
2554
2555
2556 #ifndef CONFIG_NO_WPA_MSG
2557 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
2558 {
2559         struct wpa_supplicant *wpa_s = ctx;
2560         if (wpa_s == NULL)
2561                 return NULL;
2562         return wpa_s->ifname;
2563 }
2564 #endif /* CONFIG_NO_WPA_MSG */
2565
2566
2567 /**
2568  * wpa_supplicant_init - Initialize %wpa_supplicant
2569  * @params: Parameters for %wpa_supplicant
2570  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
2571  *
2572  * This function is used to initialize %wpa_supplicant. After successful
2573  * initialization, the returned data pointer can be used to add and remove
2574  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
2575  */
2576 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
2577 {
2578         struct wpa_global *global;
2579         int ret, i;
2580
2581         if (params == NULL)
2582                 return NULL;
2583
2584 #ifdef CONFIG_DRIVER_NDIS
2585         {
2586                 void driver_ndis_init_ops(void);
2587                 driver_ndis_init_ops();
2588         }
2589 #endif /* CONFIG_DRIVER_NDIS */
2590
2591 #ifndef CONFIG_NO_WPA_MSG
2592         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
2593 #endif /* CONFIG_NO_WPA_MSG */
2594
2595         wpa_debug_open_file(params->wpa_debug_file_path);
2596         if (params->wpa_debug_syslog)
2597                 wpa_debug_open_syslog();
2598
2599         ret = eap_register_methods();
2600         if (ret) {
2601                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
2602                 if (ret == -2)
2603                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
2604                                    "the same EAP type.");
2605                 return NULL;
2606         }
2607
2608         global = os_zalloc(sizeof(*global));
2609         if (global == NULL)
2610                 return NULL;
2611         dl_list_init(&global->p2p_srv_bonjour);
2612         dl_list_init(&global->p2p_srv_upnp);
2613         global->params.daemonize = params->daemonize;
2614         global->params.wait_for_monitor = params->wait_for_monitor;
2615         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
2616         if (params->pid_file)
2617                 global->params.pid_file = os_strdup(params->pid_file);
2618         if (params->ctrl_interface)
2619                 global->params.ctrl_interface =
2620                         os_strdup(params->ctrl_interface);
2621         if (params->override_driver)
2622                 global->params.override_driver =
2623                         os_strdup(params->override_driver);
2624         if (params->override_ctrl_interface)
2625                 global->params.override_ctrl_interface =
2626                         os_strdup(params->override_ctrl_interface);
2627         wpa_debug_level = global->params.wpa_debug_level =
2628                 params->wpa_debug_level;
2629         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
2630                 params->wpa_debug_show_keys;
2631         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
2632                 params->wpa_debug_timestamp;
2633
2634         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
2635
2636         if (eloop_init()) {
2637                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
2638                 wpa_supplicant_deinit(global);
2639                 return NULL;
2640         }
2641
2642         random_init(params->entropy_file);
2643
2644         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
2645         if (global->ctrl_iface == NULL) {
2646                 wpa_supplicant_deinit(global);
2647                 return NULL;
2648         }
2649
2650         if (wpas_notify_supplicant_initialized(global)) {
2651                 wpa_supplicant_deinit(global);
2652                 return NULL;
2653         }
2654
2655         for (i = 0; wpa_drivers[i]; i++)
2656                 global->drv_count++;
2657         if (global->drv_count == 0) {
2658                 wpa_printf(MSG_ERROR, "No drivers enabled");
2659                 wpa_supplicant_deinit(global);
2660                 return NULL;
2661         }
2662         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
2663         if (global->drv_priv == NULL) {
2664                 wpa_supplicant_deinit(global);
2665                 return NULL;
2666         }
2667
2668         return global;
2669 }
2670
2671
2672 /**
2673  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
2674  * @global: Pointer to global data from wpa_supplicant_init()
2675  * Returns: 0 after successful event loop run, -1 on failure
2676  *
2677  * This function starts the main event loop and continues running as long as
2678  * there are any remaining events. In most cases, this function is running as
2679  * long as the %wpa_supplicant process in still in use.
2680  */
2681 int wpa_supplicant_run(struct wpa_global *global)
2682 {
2683         struct wpa_supplicant *wpa_s;
2684
2685         if (global->params.daemonize &&
2686             wpa_supplicant_daemon(global->params.pid_file))
2687                 return -1;
2688
2689         if (global->params.wait_for_monitor) {
2690                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
2691                         if (wpa_s->ctrl_iface)
2692                                 wpa_supplicant_ctrl_iface_wait(
2693                                         wpa_s->ctrl_iface);
2694         }
2695
2696         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
2697         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
2698
2699         eloop_run();
2700
2701         return 0;
2702 }
2703
2704
2705 /**
2706  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
2707  * @global: Pointer to global data from wpa_supplicant_init()
2708  *
2709  * This function is called to deinitialize %wpa_supplicant and to free all
2710  * allocated resources. Remaining network interfaces will also be removed.
2711  */
2712 void wpa_supplicant_deinit(struct wpa_global *global)
2713 {
2714         int i;
2715
2716         if (global == NULL)
2717                 return;
2718
2719 #ifdef CONFIG_P2P
2720         wpas_p2p_deinit_global(global);
2721 #endif /* CONFIG_P2P */
2722
2723         while (global->ifaces)
2724                 wpa_supplicant_remove_iface(global, global->ifaces);
2725
2726         if (global->ctrl_iface)
2727                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
2728
2729         wpas_notify_supplicant_deinitialized(global);
2730
2731         eap_peer_unregister_methods();
2732 #ifdef CONFIG_AP
2733         eap_server_unregister_methods();
2734 #endif /* CONFIG_AP */
2735
2736         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
2737                 if (!global->drv_priv[i])
2738                         continue;
2739                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
2740         }
2741         os_free(global->drv_priv);
2742
2743         random_deinit();
2744
2745         eloop_destroy();
2746
2747         if (global->params.pid_file) {
2748                 os_daemonize_terminate(global->params.pid_file);
2749                 os_free(global->params.pid_file);
2750         }
2751         os_free(global->params.ctrl_interface);
2752         os_free(global->params.override_driver);
2753         os_free(global->params.override_ctrl_interface);
2754
2755         os_free(global);
2756         wpa_debug_close_syslog();
2757         wpa_debug_close_file();
2758 }
2759
2760
2761 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
2762 {
2763         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
2764             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
2765                 char country[3];
2766                 country[0] = wpa_s->conf->country[0];
2767                 country[1] = wpa_s->conf->country[1];
2768                 country[2] = '\0';
2769                 if (wpa_drv_set_country(wpa_s, country) < 0) {
2770                         wpa_printf(MSG_ERROR, "Failed to set country code "
2771                                    "'%s'", country);
2772                 }
2773         }
2774
2775 #ifdef CONFIG_WPS
2776         wpas_wps_update_config(wpa_s);
2777 #endif /* CONFIG_WPS */
2778
2779 #ifdef CONFIG_P2P
2780         wpas_p2p_update_config(wpa_s);
2781 #endif /* CONFIG_P2P */
2782
2783         wpa_s->conf->changed_parameters = 0;
2784 }
2785
2786
2787 static void add_freq(int *freqs, int *num_freqs, int freq)
2788 {
2789         int i;
2790
2791         for (i = 0; i < *num_freqs; i++) {
2792                 if (freqs[i] == freq)
2793                         return;
2794         }
2795
2796         freqs[*num_freqs] = freq;
2797         (*num_freqs)++;
2798 }
2799
2800
2801 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
2802 {
2803         struct wpa_bss *bss, *cbss;
2804         const int max_freqs = 10;
2805         int *freqs;
2806         int num_freqs = 0;
2807
2808         freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
2809         if (freqs == NULL)
2810                 return NULL;
2811
2812         cbss = wpa_s->current_bss;
2813
2814         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
2815                 if (bss == cbss)
2816                         continue;
2817                 if (bss->ssid_len == cbss->ssid_len &&
2818                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
2819                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
2820                         add_freq(freqs, &num_freqs, bss->freq);
2821                         if (num_freqs == max_freqs)
2822                                 break;
2823                 }
2824         }
2825
2826         if (num_freqs == 0) {
2827                 os_free(freqs);
2828                 freqs = NULL;
2829         }
2830
2831         return freqs;
2832 }
2833
2834
2835 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
2836 {
2837         int timeout;
2838         int count;
2839         int *freqs = NULL;
2840
2841         /*
2842          * Add the failed BSSID into the blacklist and speed up next scan
2843          * attempt if there could be other APs that could accept association.
2844          * The current blacklist count indicates how many times we have tried
2845          * connecting to this AP and multiple attempts mean that other APs are
2846          * either not available or has already been tried, so that we can start
2847          * increasing the delay here to avoid constant scanning.
2848          */
2849         count = wpa_blacklist_add(wpa_s, bssid);
2850         if (count == 1 && wpa_s->current_bss) {
2851                 /*
2852                  * This BSS was not in the blacklist before. If there is
2853                  * another BSS available for the same ESS, we should try that
2854                  * next. Otherwise, we may as well try this one once more
2855                  * before allowing other, likely worse, ESSes to be considered.
2856                  */
2857                 freqs = get_bss_freqs_in_ess(wpa_s);
2858                 if (freqs) {
2859                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
2860                                 "has been seen; try it next");
2861                         wpa_blacklist_add(wpa_s, bssid);
2862                         /*
2863                          * On the next scan, go through only the known channels
2864                          * used in this ESS based on previous scans to speed up
2865                          * common load balancing use case.
2866                          */
2867                         os_free(wpa_s->next_scan_freqs);
2868                         wpa_s->next_scan_freqs = freqs;
2869                 }
2870         }
2871
2872         switch (count) {
2873         case 1:
2874                 timeout = 100;
2875                 break;
2876         case 2:
2877                 timeout = 500;
2878                 break;
2879         case 3:
2880                 timeout = 1000;
2881                 break;
2882         default:
2883                 timeout = 5000;
2884         }
2885
2886         /*
2887          * TODO: if more than one possible AP is available in scan results,
2888          * could try the other ones before requesting a new scan.
2889          */
2890         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
2891                                 1000 * (timeout % 1000));
2892 }
2893
2894
2895 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
2896 {
2897         return wpa_s->conf->ap_scan == 2 ||
2898                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
2899 }