wpa_supplicant/wpa_supplicant.c

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