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