]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/wpa_supplicant.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mesh: Reduce none 11N Self-protected Action frame allocation size
[thirdparty/hostap.git] / wpa_supplicant / wpa_supplicant.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant
b1ae396f 3 * Copyright (c) 2003-2014, Jouni Malinen <j@w1.fi>
6fc6879b 4 *
0f3d578e
JM		 5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
6fc6879b
JM		 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"
d47fa330 16#include "crypto/random.h"
7d232e23 17#include "crypto/sha1.h"
6fc6879b
JM		 18#include "eapol_supp/eapol_supp_sm.h"
19#include "eap_peer/eap.h"
ec7b97ab 20#include "eap_peer/eap_proxy.h"
3ec97afe 21#include "eap_server/eap_methods.h"
3acb5005 22#include "rsn_supp/wpa.h"
6fc6879b 23#include "eloop.h"
6fc6879b 24#include "config.h"
306ae225 25#include "utils/ext_password.h"
6fc6879b
JM		 26#include "l2_packet/l2_packet.h"
27#include "wpa_supplicant_i.h"
2d5b792d 28#include "driver_i.h"
6fc6879b 29#include "ctrl_iface.h"
6fc6879b 30#include "pcsc_funcs.h"
90973fb2 31#include "common/version.h"
3acb5005
JM		 32#include "rsn_supp/preauth.h"
33#include "rsn_supp/pmksa_cache.h"
90973fb2 34#include "common/wpa_ctrl.h"
90973fb2 35#include "common/ieee802_11_defs.h"
72044390 36#include "p2p/p2p.h"
6fc6879b
JM		 37#include "blacklist.h"
38#include "wpas_glue.h"
116654ce 39#include "wps_supplicant.h"
11ef8d35 40#include "ibss_rsn.h"
c2a04078 41#include "sme.h"
04ea7b79 42#include "gas_query.h"
1f1b62a0 43#include "ap.h"
b22128ef 44#include "p2p_supplicant.h"
9675ce35 45#include "wifi_display.h"
8bac466b 46#include "notify.h"
60b94c98 47#include "bgscan.h"
7c865c68 48#include "autoscan.h"
83922c2d 49#include "bss.h"
9ba9fa07 50#include "scan.h"
24f6497c 51#include "offchannel.h"
cb418324 52#include "hs20_supplicant.h"
e27d20bb 53#include "wnm_sta.h"
dd10abcc 54#include "wpas_kay.h"
6fc6879b
JM		 55
56const char *wpa_supplicant_version =
57"wpa_supplicant v" VERSION_STR "\n"
b1ae396f 58"Copyright (c) 2003-2014, Jouni Malinen <j@w1.fi> and contributors";
6fc6879b
JM		 59
60const char *wpa_supplicant_license =
331f89ff
JM		 61"This software may be distributed under the terms of the BSD license.\n"
62"See README for more details.\n"
6fc6879b
JM		 63#ifdef EAP_TLS_OPENSSL
64"\nThis product includes software developed by the OpenSSL Project\n"
65"for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
66#endif /* EAP_TLS_OPENSSL */
67;
68
69#ifndef CONFIG_NO_STDOUT_DEBUG
70/* Long text divided into parts in order to fit in C89 strings size limits. */
71const char *wpa_supplicant_full_license1 =
331f89ff 72"";
6fc6879b 73const char *wpa_supplicant_full_license2 =
331f89ff 74"This software may be distributed under the terms of the BSD license.\n"
6fc6879b
JM		 75"\n"
76"Redistribution and use in source and binary forms, with or without\n"
77"modification, are permitted provided that the following conditions are\n"
78"met:\n"
79"\n";
80const char *wpa_supplicant_full_license3 =
81"1. Redistributions of source code must retain the above copyright\n"
82" notice, this list of conditions and the following disclaimer.\n"
83"\n"
84"2. Redistributions in binary form must reproduce the above copyright\n"
85" notice, this list of conditions and the following disclaimer in the\n"
86" documentation and/or other materials provided with the distribution.\n"
87"\n";
88const char *wpa_supplicant_full_license4 =
89"3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
90" names of its contributors may be used to endorse or promote products\n"
91" derived from this software without specific prior written permission.\n"
92"\n"
93"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
94"\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
95"LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
96"A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
97const char *wpa_supplicant_full_license5 =
98"OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
99"SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
100"LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
101"DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
102"THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
103"(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
104"OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
105"\n";
106#endif /* CONFIG_NO_STDOUT_DEBUG */
107
6fc6879b 108/* Configure default/group WEP keys for static WEP */
0194fedb 109int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
6fc6879b
JM		 110{
111 int i, set = 0;
112
113 for (i = 0; i < NUM_WEP_KEYS; i++) {
114 if (ssid->wep_key_len[i] == 0)
115 continue;
116
117 set = 1;
0382097e 118 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
da64c266 119 i, i == ssid->wep_tx_keyidx, NULL, 0,
6fc6879b
JM		 120 ssid->wep_key[i], ssid->wep_key_len[i]);
121 }
122
123 return set;
124}
125
126
6ea1f413
JM		 127int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
128 struct wpa_ssid *ssid)
6fc6879b
JM		 129{
130 u8 key[32];
131 size_t keylen;
71934751 132 enum wpa_alg alg;
6fc6879b
JM		 133 u8 seq[6] = { 0 };
134
135 /* IBSS/WPA-None uses only one key (Group) for both receiving and
136 * sending unicast and multicast packets. */
137
d7dcba70 138 if (ssid->mode != WPAS_MODE_IBSS) {
f049052b
BG		 139 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
140 "IBSS/ad-hoc) for WPA-None", ssid->mode);
6fc6879b
JM		 141 return -1;
142 }
143
144 if (!ssid->psk_set) {
f049052b
BG		 145 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
146 "WPA-None");
6fc6879b
JM		 147 return -1;
148 }
149
150 switch (wpa_s->group_cipher) {
151 case WPA_CIPHER_CCMP:
152 os_memcpy(key, ssid->psk, 16);
153 keylen = 16;
154 alg = WPA_ALG_CCMP;
155 break;
eb7719ff
JM		 156 case WPA_CIPHER_GCMP:
157 os_memcpy(key, ssid->psk, 16);
158 keylen = 16;
159 alg = WPA_ALG_GCMP;
160 break;
6fc6879b
JM		 161 case WPA_CIPHER_TKIP:
162 /* WPA-None uses the same Michael MIC key for both TX and RX */
163 os_memcpy(key, ssid->psk, 16 + 8);
164 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
165 keylen = 32;
166 alg = WPA_ALG_TKIP;
167 break;
168 default:
f049052b
BG		 169 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
170 "WPA-None", wpa_s->group_cipher);
6fc6879b
JM		 171 return -1;
172 }
173
174 /* TODO: should actually remember the previously used seq#, both for TX
175 * and RX from each STA.. */
176
0382097e 177 return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
6fc6879b
JM		 178}
179
180
181static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
182{
183 struct wpa_supplicant *wpa_s = eloop_ctx;
184 const u8 *bssid = wpa_s->bssid;
a8e16edc 185 if (is_zero_ether_addr(bssid))
6fc6879b
JM		 186 bssid = wpa_s->pending_bssid;
187 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
188 MAC2STR(bssid));
189 wpa_blacklist_add(wpa_s, bssid);
190 wpa_sm_notify_disassoc(wpa_s->wpa);
07783eaa 191 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
6fc6879b 192 wpa_s->reassociate = 1;
48b84f18
BG		 193
194 /*
195 * If we timed out, the AP or the local radio may be busy.
196 * So, wait a second until scanning again.
197 */
198 wpa_supplicant_req_scan(wpa_s, 1, 0);
6fc6879b
JM		 199}
200
201
202/**
203 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
204 * @wpa_s: Pointer to wpa_supplicant data
205 * @sec: Number of seconds after which to time out authentication
206 * @usec: Number of microseconds after which to time out authentication
207 *
208 * This function is used to schedule a timeout for the current authentication
209 * attempt.
210 */
211void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
212 int sec, int usec)
213{
a2a535f8 214 if (wpa_s->conf->ap_scan == 0 &&
c2a04078 215 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
6fc6879b
JM		 216 return;
217
f049052b 218 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
6fc6879b
JM		 219 "%d usec", sec, usec);
220 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
221 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
222}
223
224
225/**
226 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
227 * @wpa_s: Pointer to wpa_supplicant data
228 *
229 * This function is used to cancel authentication timeout scheduled with
230 * wpa_supplicant_req_auth_timeout() and it is called when authentication has
231 * been completed.
232 */
233void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
234{
f049052b 235 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
6fc6879b
JM		 236 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
237 wpa_blacklist_del(wpa_s, wpa_s->bssid);
238}
239
240
241/**
242 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
243 * @wpa_s: Pointer to wpa_supplicant data
244 *
245 * This function is used to configure EAPOL state machine based on the selected
246 * authentication mode.
247 */
248void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
249{
250#ifdef IEEE8021X_EAPOL
251 struct eapol_config eapol_conf;
252 struct wpa_ssid *ssid = wpa_s->current_ssid;
253
53895c3b 254#ifdef CONFIG_IBSS_RSN
d7dcba70 255 if (ssid->mode == WPAS_MODE_IBSS &&
53895c3b
JM		 256 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
257 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
258 /*
259 * RSN IBSS authentication is per-STA and we can disable the
260 * per-BSSID EAPOL authentication.
261 */
262 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
263 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
264 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
265 return;
266 }
267#endif /* CONFIG_IBSS_RSN */
268
0a40ec6a
JM		 269 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
270 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
271
6fc6879b
JM		 272 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
273 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
274 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
275 else
276 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
277
278 os_memset(&eapol_conf, 0, sizeof(eapol_conf));
279 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
280 eapol_conf.accept_802_1x_keys = 1;
281 eapol_conf.required_keys = 0;
282 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
283 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
284 }
285 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
286 eapol_conf.required_keys |=
287 EAPOL_REQUIRE_KEY_BROADCAST;
288 }
289
a2a535f8 290 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
6fc6879b 291 eapol_conf.required_keys = 0;
6fc6879b 292 }
a2a535f8 293 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
6fc6879b 294 eapol_conf.workaround = ssid->eap_workaround;
56586197
JM		 295 eapol_conf.eap_disabled =
296 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
ad08c363
JM		 297 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
298 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
a5d44ac0 299 eapol_conf.external_sim = wpa_s->conf->external_sim;
3f7ac058
JS		 300
301#ifdef CONFIG_WPS
302 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
303 eapol_conf.wps |= EAPOL_LOCAL_WPS_IN_USE;
304 if (wpa_s->current_bss) {
305 struct wpabuf *ie;
306 ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
307 WPS_IE_VENDOR_TYPE);
308 if (ie) {
309 if (wps_is_20(ie))
310 eapol_conf.wps |=
311 EAPOL_PEER_IS_WPS20_AP;
312 wpabuf_free(ie);
313 }
314 }
315 }
316#endif /* CONFIG_WPS */
317
6fc6879b 318 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
dd10abcc
HW		 319
320 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
cd3153a9 321#endif /* IEEE8021X_EAPOL */
6fc6879b
JM		 322}
323
324
325/**
326 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
327 * @wpa_s: Pointer to wpa_supplicant data
328 * @ssid: Configuration data for the network
329 *
330 * This function is used to configure WPA state machine and related parameters
331 * to a mode where WPA is not enabled. This is called as part of the
332 * authentication configuration when the selected network does not use WPA.
333 */
334void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
335 struct wpa_ssid *ssid)
336{
337 int i;
338
ad08c363
JM		 339 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
340 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
341 else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
6fc6879b
JM		 342 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
343 else
344 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
345 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
346 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
347 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
348 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
349 wpa_s->group_cipher = WPA_CIPHER_NONE;
350 wpa_s->mgmt_group_cipher = 0;
351
352 for (i = 0; i < NUM_WEP_KEYS; i++) {
353 if (ssid->wep_key_len[i] > 5) {
354 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
355 wpa_s->group_cipher = WPA_CIPHER_WEP104;
356 break;
357 } else if (ssid->wep_key_len[i] > 0) {
358 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
359 wpa_s->group_cipher = WPA_CIPHER_WEP40;
360 break;
361 }
362 }
363
364 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
365 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
366 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
367 wpa_s->pairwise_cipher);
368 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
369#ifdef CONFIG_IEEE80211W
370 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
371 wpa_s->mgmt_group_cipher);
372#endif /* CONFIG_IEEE80211W */
373
374 pmksa_cache_clear_current(wpa_s->wpa);
375}
376
377
6979582c 378void free_hw_features(struct wpa_supplicant *wpa_s)
6bf731e8
CL		 379{
380 int i;
381 if (wpa_s->hw.modes == NULL)
382 return;
383
384 for (i = 0; i < wpa_s->hw.num_modes; i++) {
385 os_free(wpa_s->hw.modes[i].channels);
386 os_free(wpa_s->hw.modes[i].rates);
387 }
388
389 os_free(wpa_s->hw.modes);
390 wpa_s->hw.modes = NULL;
391}
392
393
6fc6879b
JM		 394static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
395{
86bd36f0
JM		 396 int i;
397
60b94c98 398 bgscan_deinit(wpa_s);
7c865c68 399 autoscan_deinit(wpa_s);
6fc6879b
JM		 400 scard_deinit(wpa_s->scard);
401 wpa_s->scard = NULL;
402 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
403 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
404 l2_packet_deinit(wpa_s->l2);
405 wpa_s->l2 = NULL;
406 if (wpa_s->l2_br) {
407 l2_packet_deinit(wpa_s->l2_br);
408 wpa_s->l2_br = NULL;
409 }
4a6cc862
JM		 410#ifdef CONFIG_TESTING_OPTIONS
411 l2_packet_deinit(wpa_s->l2_test);
412 wpa_s->l2_test = NULL;
413#endif /* CONFIG_TESTING_OPTIONS */
6fc6879b 414
6fc6879b 415 if (wpa_s->conf != NULL) {
8e56d189
JM		 416 struct wpa_ssid *ssid;
417 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
418 wpas_notify_network_removed(wpa_s, ssid);
6fc6879b
JM		 419 }
420
421 os_free(wpa_s->confname);
422 wpa_s->confname = NULL;
423
e6304cad
DS		 424 os_free(wpa_s->confanother);
425 wpa_s->confanother = NULL;
426
6fc6879b
JM		 427 wpa_sm_set_eapol(wpa_s->wpa, NULL);
428 eapol_sm_deinit(wpa_s->eapol);
429 wpa_s->eapol = NULL;
430
431 rsn_preauth_deinit(wpa_s->wpa);
432
281ff0aa
GP		 433#ifdef CONFIG_TDLS
434 wpa_tdls_deinit(wpa_s->wpa);
435#endif /* CONFIG_TDLS */
436
6fc6879b
JM		 437 pmksa_candidate_free(wpa_s->wpa);
438 wpa_sm_deinit(wpa_s->wpa);
439 wpa_s->wpa = NULL;
440 wpa_blacklist_clear(wpa_s);
441
83922c2d 442 wpa_bss_deinit(wpa_s);
6fc6879b 443
831770bf 444 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
6fc6879b
JM		 445 wpa_supplicant_cancel_scan(wpa_s);
446 wpa_supplicant_cancel_auth_timeout(wpa_s);
01a17491
JM		 447 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
448#ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
449 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
450 wpa_s, NULL);
451#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
6fc6879b 452
116654ce 453 wpas_wps_deinit(wpa_s);
11ef8d35 454
1ff73338
JM		 455 wpabuf_free(wpa_s->pending_eapol_rx);
456 wpa_s->pending_eapol_rx = NULL;
457
11ef8d35
JM		 458#ifdef CONFIG_IBSS_RSN
459 ibss_rsn_deinit(wpa_s->ibss_rsn);
460 wpa_s->ibss_rsn = NULL;
461#endif /* CONFIG_IBSS_RSN */
c2a04078 462
e29853bb 463 sme_deinit(wpa_s);
2d5b792d
JM		 464
465#ifdef CONFIG_AP
466 wpa_supplicant_ap_deinit(wpa_s);
467#endif /* CONFIG_AP */
b22128ef 468
b22128ef 469 wpas_p2p_deinit(wpa_s);
f47d639d 470
24f6497c
JM		 471#ifdef CONFIG_OFFCHANNEL
472 offchannel_deinit(wpa_s);
473#endif /* CONFIG_OFFCHANNEL */
474
a4cba8f1
LC		 475 wpa_supplicant_cancel_sched_scan(wpa_s);
476
f47d639d
JM		 477 os_free(wpa_s->next_scan_freqs);
478 wpa_s->next_scan_freqs = NULL;
fee52342
JM		 479
480 os_free(wpa_s->manual_scan_freqs);
481 wpa_s->manual_scan_freqs = NULL;
04ea7b79 482
d3c9c35f
DS		 483 os_free(wpa_s->manual_sched_scan_freqs);
484 wpa_s->manual_sched_scan_freqs = NULL;
485
04ea7b79
JM		 486 gas_query_deinit(wpa_s->gas);
487 wpa_s->gas = NULL;
6bf731e8
CL		 488
489 free_hw_features(wpa_s);
d445a5cd 490
dd10abcc
HW		 491 ieee802_1x_dealloc_kay_sm(wpa_s);
492
d445a5cd
JM		 493 os_free(wpa_s->bssid_filter);
494 wpa_s->bssid_filter = NULL;
b6668734 495
6407f413
JM		 496 os_free(wpa_s->disallow_aps_bssid);
497 wpa_s->disallow_aps_bssid = NULL;
498 os_free(wpa_s->disallow_aps_ssid);
499 wpa_s->disallow_aps_ssid = NULL;
500
b6668734 501 wnm_bss_keep_alive_deinit(wpa_s);
e27d20bb
VK		 502#ifdef CONFIG_WNM
503 wnm_deallocate_memory(wpa_s);
504#endif /* CONFIG_WNM */
306ae225
JM		 505
506 ext_password_deinit(wpa_s->ext_pw);
507 wpa_s->ext_pw = NULL;
b1f12296
JM		 508
509 wpabuf_free(wpa_s->last_gas_resp);
b6a9590b
JM		 510 wpa_s->last_gas_resp = NULL;
511 wpabuf_free(wpa_s->prev_gas_resp);
512 wpa_s->prev_gas_resp = NULL;
a297201d
JM		 513
514 os_free(wpa_s->last_scan_res);
515 wpa_s->last_scan_res = NULL;
b572df86
JM		 516
517#ifdef CONFIG_HS20
fb2ac53d 518 hs20_deinit(wpa_s);
b572df86 519#endif /* CONFIG_HS20 */
86bd36f0
JM		 520
521 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
522 wpabuf_free(wpa_s->vendor_elem[i]);
523 wpa_s->vendor_elem[i] = NULL;
524 }
6fc6879b
JM		 525}
526
527
528/**
529 * wpa_clear_keys - Clear keys configured for the driver
530 * @wpa_s: Pointer to wpa_supplicant data
531 * @addr: Previously used BSSID or %NULL if not available
532 *
533 * This function clears the encryption keys that has been previously configured
534 * for the driver.
535 */
536void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
537{
2f30cac3 538 int i, max;
6fc6879b 539
0e27f655 540#ifdef CONFIG_IEEE80211W
2f30cac3
JM		 541 max = 6;
542#else /* CONFIG_IEEE80211W */
543 max = 4;
0e27f655 544#endif /* CONFIG_IEEE80211W */
2f30cac3
JM		 545
546 /* MLME-DELETEKEYS.request */
547 for (i = 0; i < max; i++) {
548 if (wpa_s->keys_cleared & BIT(i))
549 continue;
550 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
551 NULL, 0);
552 }
553 if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
554 !is_zero_ether_addr(addr)) {
6fc6879b
JM		 555 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
556 0);
557 /* MLME-SETPROTECTION.request(None) */
558 wpa_drv_mlme_setprotection(
559 wpa_s, addr,
560 MLME_SETPROTECTION_PROTECT_TYPE_NONE,
561 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
562 }
2f30cac3 563 wpa_s->keys_cleared = (u32) -1;
6fc6879b
JM		 564}
565
566
567/**
568 * wpa_supplicant_state_txt - Get the connection state name as a text string
569 * @state: State (wpa_state; WPA_*)
570 * Returns: The state name as a printable text string
571 */
71934751 572const char * wpa_supplicant_state_txt(enum wpa_states state)
6fc6879b
JM		 573{
574 switch (state) {
575 case WPA_DISCONNECTED:
576 return "DISCONNECTED";
577 case WPA_INACTIVE:
578 return "INACTIVE";
8401a6b0
JM		 579 case WPA_INTERFACE_DISABLED:
580 return "INTERFACE_DISABLED";
6fc6879b
JM		 581 case WPA_SCANNING:
582 return "SCANNING";
c2a04078
JM		 583 case WPA_AUTHENTICATING:
584 return "AUTHENTICATING";
6fc6879b
JM		 585 case WPA_ASSOCIATING:
586 return "ASSOCIATING";
587 case WPA_ASSOCIATED:
588 return "ASSOCIATED";
589 case WPA_4WAY_HANDSHAKE:
590 return "4WAY_HANDSHAKE";
591 case WPA_GROUP_HANDSHAKE:
592 return "GROUP_HANDSHAKE";
593 case WPA_COMPLETED:
594 return "COMPLETED";
595 default:
596 return "UNKNOWN";
597 }
598}
599
600
cfe53c9a
PS		 601#ifdef CONFIG_BGSCAN
602
603static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
604{
31392709
HD		 605 const char *name;
606
607 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
608 name = wpa_s->current_ssid->bgscan;
609 else
610 name = wpa_s->conf->bgscan;
268043d5 611 if (name == NULL || name[0] == '\0')
31392709 612 return;
0096c427
JM		 613 if (wpas_driver_bss_selection(wpa_s))
614 return;
cfe53c9a
PS		 615 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
616 return;
aa109830
DS		 617#ifdef CONFIG_P2P
618 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
619 return;
620#endif /* CONFIG_P2P */
cfe53c9a
PS		 621
622 bgscan_deinit(wpa_s);
31392709
HD		 623 if (wpa_s->current_ssid) {
624 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
cfe53c9a
PS		 625 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
626 "bgscan");
627 /*
628 * Live without bgscan; it is only used as a roaming
629 * optimization, so the initial connection is not
630 * affected.
631 */
6409b7a7
YD		 632 } else {
633 struct wpa_scan_results *scan_res;
cfe53c9a 634 wpa_s->bgscan_ssid = wpa_s->current_ssid;
6409b7a7
YD		 635 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
636 0);
637 if (scan_res) {
638 bgscan_notify_scan(wpa_s, scan_res);
639 wpa_scan_results_free(scan_res);
640 }
641 }
cfe53c9a
PS		 642 } else
643 wpa_s->bgscan_ssid = NULL;
644}
645
646
647static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
648{
649 if (wpa_s->bgscan_ssid != NULL) {
650 bgscan_deinit(wpa_s);
651 wpa_s->bgscan_ssid = NULL;
652 }
653}
654
655#endif /* CONFIG_BGSCAN */
656
657
7c865c68
TB		 658static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
659{
99218999 660 if (autoscan_init(wpa_s, 0))
7c865c68
TB		 661 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
662}
663
664
665static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
666{
667 autoscan_deinit(wpa_s);
668}
669
670
c3d12238
JM		 671void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
672{
673 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
674 wpa_s->wpa_state == WPA_SCANNING) {
675 autoscan_deinit(wpa_s);
676 wpa_supplicant_start_autoscan(wpa_s);
677 }
678}
679
680
6fc6879b
JM		 681/**
682 * wpa_supplicant_set_state - Set current connection state
683 * @wpa_s: Pointer to wpa_supplicant data
684 * @state: The new connection state
685 *
686 * This function is called whenever the connection state changes, e.g.,
687 * association is completed for WPA/WPA2 4-Way Handshake is started.
688 */
71934751
JM		 689void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
690 enum wpa_states state)
6fc6879b 691{
27f43d8d
MH		 692 enum wpa_states old_state = wpa_s->wpa_state;
693
f049052b
BG		 694 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
695 wpa_supplicant_state_txt(wpa_s->wpa_state),
696 wpa_supplicant_state_txt(state));
6fc6879b 697
5ddd07cb
AS		 698 if (state == WPA_INTERFACE_DISABLED) {
699 /* Assure normal scan when interface is restored */
700 wpa_s->normal_scans = 0;
701 }
702
0cf24fda 703 if (state == WPA_COMPLETED) {
6ac4b15e 704 wpas_connect_work_done(wpa_s);
0cf24fda
LC		 705 /* Reinitialize normal_scan counter */
706 wpa_s->normal_scans = 0;
707 }
6ac4b15e 708
cb8564b1
DW		 709 if (state != WPA_SCANNING)
710 wpa_supplicant_notify_scanning(wpa_s, 0);
711
6fc6879b 712 if (state == WPA_COMPLETED && wpa_s->new_connection) {
6fc6879b 713 struct wpa_ssid *ssid = wpa_s->current_ssid;
7d37a357 714#if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
6fc6879b 715 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
1cfc6787
JM		 716 MACSTR " completed [id=%d id_str=%s]",
717 MAC2STR(wpa_s->bssid),
6fc6879b
JM		 718 ssid ? ssid->id : -1,
719 ssid && ssid->id_str ? ssid->id_str : "");
720#endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
00e5e3d5 721 wpas_clear_temp_disabled(wpa_s, ssid, 1);
f1a52633 722 wpa_s->extra_blacklist_count = 0;
6fc6879b 723 wpa_s->new_connection = 0;
6fc6879b 724 wpa_drv_set_operstate(wpa_s, 1);
99ac2913
FF		 725#ifndef IEEE8021X_EAPOL
726 wpa_drv_set_supp_port(wpa_s, 1);
727#endif /* IEEE8021X_EAPOL */
17a4734d 728 wpa_s->after_wps = 0;
4d9fb08d 729 wpa_s->known_wps_freq = 0;
b22128ef 730 wpas_p2p_completed(wpa_s);
c3701c66
RM		 731
732 sme_sched_obss_scan(wpa_s, 1);
6fc6879b
JM		 733 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
734 state == WPA_ASSOCIATED) {
735 wpa_s->new_connection = 1;
736 wpa_drv_set_operstate(wpa_s, 0);
99ac2913
FF		 737#ifndef IEEE8021X_EAPOL
738 wpa_drv_set_supp_port(wpa_s, 0);
739#endif /* IEEE8021X_EAPOL */
c3701c66 740 sme_sched_obss_scan(wpa_s, 0);
6fc6879b
JM		 741 }
742 wpa_s->wpa_state = state;
27f43d8d 743
cfe53c9a
PS		 744#ifdef CONFIG_BGSCAN
745 if (state == WPA_COMPLETED)
746 wpa_supplicant_start_bgscan(wpa_s);
37271232 747 else if (state < WPA_ASSOCIATED)
cfe53c9a
PS		 748 wpa_supplicant_stop_bgscan(wpa_s);
749#endif /* CONFIG_BGSCAN */
750
7c865c68
TB		 751 if (state == WPA_AUTHENTICATING)
752 wpa_supplicant_stop_autoscan(wpa_s);
753
754 if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
755 wpa_supplicant_start_autoscan(wpa_s);
756
5bbf9f10 757 if (wpa_s->wpa_state != old_state) {
27f43d8d 758 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
5bbf9f10 759
e3bd6e9d
IP		 760 /*
761 * Notify the P2P Device interface about a state change in one
762 * of the interfaces.
763 */
764 wpas_p2p_indicate_state_change(wpa_s);
e3bd6e9d 765
5bbf9f10
PS		 766 if (wpa_s->wpa_state == WPA_COMPLETED ||
767 old_state == WPA_COMPLETED)
768 wpas_notify_auth_changed(wpa_s);
769 }
6fc6879b
JM		 770}
771
772
1a1bf008
JM		 773void wpa_supplicant_terminate_proc(struct wpa_global *global)
774{
775 int pending = 0;
776#ifdef CONFIG_WPS
777 struct wpa_supplicant *wpa_s = global->ifaces;
778 while (wpa_s) {
ab41595f 779 struct wpa_supplicant *next = wpa_s->next;
5516ed32
EA		 780 if (wpas_wps_terminate_pending(wpa_s) == 1)
781 pending = 1;
20625e97
JM		 782#ifdef CONFIG_P2P
783 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
784 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
785 wpas_p2p_disconnect(wpa_s);
786#endif /* CONFIG_P2P */
ab41595f 787 wpa_s = next;
1a1bf008
JM		 788 }
789#endif /* CONFIG_WPS */
790 if (pending)
791 return;
792 eloop_terminate();
793}
794
795
0456ea16 796static void wpa_supplicant_terminate(int sig, void *signal_ctx)
6fc6879b 797{
0456ea16 798 struct wpa_global *global = signal_ctx;
1a1bf008 799 wpa_supplicant_terminate_proc(global);
6fc6879b
JM		 800}
801
802
b22128ef 803void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
6fc6879b 804{
71934751 805 enum wpa_states old_state = wpa_s->wpa_state;
27f43d8d 806
6fc6879b
JM		 807 wpa_s->pairwise_cipher = 0;
808 wpa_s->group_cipher = 0;
809 wpa_s->mgmt_group_cipher = 0;
810 wpa_s->key_mgmt = 0;
8401a6b0 811 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
99218999 812 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
27f43d8d
MH		 813
814 if (wpa_s->wpa_state != old_state)
815 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
6fc6879b
JM		 816}
817
818
819/**
820 * wpa_supplicant_reload_configuration - Reload configuration data
821 * @wpa_s: Pointer to wpa_supplicant data
822 * Returns: 0 on success or -1 if configuration parsing failed
823 *
824 * This function can be used to request that the configuration data is reloaded
825 * (e.g., after configuration file change). This function is reloading
826 * configuration only for one interface, so this may need to be called multiple
827 * times if %wpa_supplicant is controlling multiple interfaces and all
828 * interfaces need reconfiguration.
829 */
830int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
831{
832 struct wpa_config *conf;
833 int reconf_ctrl;
8bac466b
JM		 834 int old_ap_scan;
835
6fc6879b
JM		 836 if (wpa_s->confname == NULL)
837 return -1;
e6304cad 838 conf = wpa_config_read(wpa_s->confname, NULL);
6fc6879b
JM		 839 if (conf == NULL) {
840 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
841 "file '%s' - exiting", wpa_s->confname);
842 return -1;
843 }
e6304cad
DS		 844 wpa_config_read(wpa_s->confanother, conf);
845
611aea7d 846 conf->changed_parameters = (unsigned int) -1;
6fc6879b
JM		 847
848 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
849 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
850 os_strcmp(conf->ctrl_interface,
851 wpa_s->conf->ctrl_interface) != 0);
852
853 if (reconf_ctrl && wpa_s->ctrl_iface) {
854 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
855 wpa_s->ctrl_iface = NULL;
856 }
857
858 eapol_sm_invalidate_cached_session(wpa_s->eapol);
7b7ce8aa
JM		 859 if (wpa_s->current_ssid) {
860 wpa_supplicant_deauthenticate(wpa_s,
861 WLAN_REASON_DEAUTH_LEAVING);
862 }
8bac466b 863
6fc6879b
JM		 864 /*
865 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
07e2de31 866 * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers.
6fc6879b 867 */
56586197 868 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
6fc6879b
JM		 869 /*
870 * Clear forced success to clear EAP state for next
871 * authentication.
872 */
873 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
874 }
875 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
876 wpa_sm_set_config(wpa_s->wpa, NULL);
d8a790b9 877 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
6fc6879b
JM		 878 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
879 rsn_preauth_deinit(wpa_s->wpa);
8bac466b
JM		 880
881 old_ap_scan = wpa_s->conf->ap_scan;
6fc6879b
JM		 882 wpa_config_free(wpa_s->conf);
883 wpa_s->conf = conf;
8bac466b
JM		 884 if (old_ap_scan != wpa_s->conf->ap_scan)
885 wpas_notify_ap_scan_changed(wpa_s);
886
6fc6879b
JM		 887 if (reconf_ctrl)
888 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
889
611aea7d
JM		 890 wpa_supplicant_update_config(wpa_s);
891
6fc6879b 892 wpa_supplicant_clear_status(wpa_s);
349493bd 893 if (wpa_supplicant_enabled_networks(wpa_s)) {
43a38635
JM		 894 wpa_s->reassociate = 1;
895 wpa_supplicant_req_scan(wpa_s, 0, 0);
896 }
f049052b 897 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
6fc6879b
JM		 898 return 0;
899}
900
901
0456ea16 902static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
6fc6879b 903{
0456ea16 904 struct wpa_global *global = signal_ctx;
6fc6879b 905 struct wpa_supplicant *wpa_s;
6fc6879b 906 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
f049052b
BG		 907 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
908 sig);
6fc6879b 909 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
1a1bf008 910 wpa_supplicant_terminate_proc(global);
6fc6879b
JM		 911 }
912 }
913}
914
915
6fc6879b
JM		 916static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
917 struct wpa_ssid *ssid,
918 struct wpa_ie_data *ie)
919{
920 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
921 if (ret) {
922 if (ret == -2) {
923 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
924 "from association info");
925 }
926 return -1;
927 }
928
f049052b
BG		 929 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
930 "cipher suites");
6fc6879b
JM		 931 if (!(ie->group_cipher & ssid->group_cipher)) {
932 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
933 "cipher 0x%x (mask 0x%x) - reject",
934 ie->group_cipher, ssid->group_cipher);
935 return -1;
936 }
937 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
938 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
939 "cipher 0x%x (mask 0x%x) - reject",
940 ie->pairwise_cipher, ssid->pairwise_cipher);
941 return -1;
942 }
943 if (!(ie->key_mgmt & ssid->key_mgmt)) {
944 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
945 "management 0x%x (mask 0x%x) - reject",
946 ie->key_mgmt, ssid->key_mgmt);
947 return -1;
948 }
949
950#ifdef CONFIG_IEEE80211W
0b60b0aa 951 if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
62d49803
JM		 952 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
953 wpa_s->conf->pmf : ssid->ieee80211w) ==
954 MGMT_FRAME_PROTECTION_REQUIRED) {
6fc6879b
JM		 955 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
956 "that does not support management frame protection - "
957 "reject");
958 return -1;
959 }
960#endif /* CONFIG_IEEE80211W */
961
962 return 0;
963}
964
965
966/**
967 * wpa_supplicant_set_suites - Set authentication and encryption parameters
968 * @wpa_s: Pointer to wpa_supplicant data
969 * @bss: Scan results for the selected BSS, or %NULL if not available
970 * @ssid: Configuration data for the selected network
971 * @wpa_ie: Buffer for the WPA/RSN IE
972 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
973 * used buffer length in case the functions returns success.
974 * Returns: 0 on success or -1 on failure
975 *
976 * This function is used to configure authentication and encryption parameters
977 * based on the network configuration and scan result for the selected BSS (if
978 * available).
979 */
980int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
6fa81a3b 981 struct wpa_bss *bss, struct wpa_ssid *ssid,
6fc6879b
JM		 982 u8 *wpa_ie, size_t *wpa_ie_len)
983{
984 struct wpa_ie_data ie;
985 int sel, proto;
df0f01d9 986 const u8 *bss_wpa, *bss_rsn, *bss_osen;
6fc6879b
JM		 987
988 if (bss) {
6fa81a3b
JM		 989 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
990 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
df0f01d9 991 bss_osen = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
6fc6879b 992 } else
df0f01d9 993 bss_wpa = bss_rsn = bss_osen = NULL;
6fc6879b
JM		 994
995 if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
996 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
997 (ie.group_cipher & ssid->group_cipher) &&
998 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
999 (ie.key_mgmt & ssid->key_mgmt)) {
f049052b 1000 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
6fc6879b
JM		 1001 proto = WPA_PROTO_RSN;
1002 } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
1003 wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
1004 (ie.group_cipher & ssid->group_cipher) &&
1005 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1006 (ie.key_mgmt & ssid->key_mgmt)) {
f049052b 1007 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
6fc6879b 1008 proto = WPA_PROTO_WPA;
df0f01d9
JM		 1009#ifdef CONFIG_HS20
1010 } else if (bss_osen && (ssid->proto & WPA_PROTO_OSEN)) {
1011 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1012 /* TODO: parse OSEN element */
137ff332 1013 os_memset(&ie, 0, sizeof(ie));
df0f01d9
JM		 1014 ie.group_cipher = WPA_CIPHER_CCMP;
1015 ie.pairwise_cipher = WPA_CIPHER_CCMP;
1016 ie.key_mgmt = WPA_KEY_MGMT_OSEN;
1017 proto = WPA_PROTO_OSEN;
1018#endif /* CONFIG_HS20 */
6fc6879b
JM		 1019 } else if (bss) {
1020 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1021 return -1;
1022 } else {
df0f01d9
JM		 1023 if (ssid->proto & WPA_PROTO_OSEN)
1024 proto = WPA_PROTO_OSEN;
1025 else if (ssid->proto & WPA_PROTO_RSN)
6fc6879b
JM		 1026 proto = WPA_PROTO_RSN;
1027 else
1028 proto = WPA_PROTO_WPA;
1029 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1030 os_memset(&ie, 0, sizeof(ie));
1031 ie.group_cipher = ssid->group_cipher;
1032 ie.pairwise_cipher = ssid->pairwise_cipher;
1033 ie.key_mgmt = ssid->key_mgmt;
1034#ifdef CONFIG_IEEE80211W
1035 ie.mgmt_group_cipher =
70f8cc8e 1036 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
6fc6879b
JM		 1037 WPA_CIPHER_AES_128_CMAC : 0;
1038#endif /* CONFIG_IEEE80211W */
f049052b
BG		 1039 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1040 "based on configuration");
6fc6879b
JM		 1041 } else
1042 proto = ie.proto;
1043 }
1044
f049052b
BG		 1045 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1046 "pairwise %d key_mgmt %d proto %d",
1047 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
6fc6879b
JM		 1048#ifdef CONFIG_IEEE80211W
1049 if (ssid->ieee80211w) {
f049052b
BG		 1050 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1051 ie.mgmt_group_cipher);
6fc6879b
JM		 1052 }
1053#endif /* CONFIG_IEEE80211W */
1054
64fa840a 1055 wpa_s->wpa_proto = proto;
6fc6879b
JM		 1056 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1057 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
df0f01d9 1058 !!(ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN)));
6fc6879b
JM		 1059
1060 if (bss || !wpa_s->ap_ies_from_associnfo) {
1061 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1062 bss_wpa ? 2 + bss_wpa[1] : 0) ||
1063 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1064 bss_rsn ? 2 + bss_rsn[1] : 0))
1065 return -1;
1066 }
1067
1068 sel = ie.group_cipher & ssid->group_cipher;
edbd2a19
JM		 1069 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1070 if (wpa_s->group_cipher < 0) {
f049052b
BG		 1071 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1072 "cipher");
6fc6879b
JM		 1073 return -1;
1074 }
edbd2a19
JM		 1075 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1076 wpa_cipher_txt(wpa_s->group_cipher));
6fc6879b
JM		 1077
1078 sel = ie.pairwise_cipher & ssid->pairwise_cipher;
edbd2a19
JM		 1079 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1080 if (wpa_s->pairwise_cipher < 0) {
f049052b
BG		 1081 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1082 "cipher");
6fc6879b
JM		 1083 return -1;
1084 }
edbd2a19
JM		 1085 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1086 wpa_cipher_txt(wpa_s->pairwise_cipher));
6fc6879b
JM		 1087
1088 sel = ie.key_mgmt & ssid->key_mgmt;
c10347f2
JM		 1089#ifdef CONFIG_SAE
1090 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1091 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE);
1092#endif /* CONFIG_SAE */
6fc6879b 1093 if (0) {
666497c8
JM		 1094 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
1095 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1096 wpa_dbg(wpa_s, MSG_DEBUG,
1097 "WPA: using KEY_MGMT 802.1X with Suite B");
6fc6879b
JM		 1098#ifdef CONFIG_IEEE80211R
1099 } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1100 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
f049052b 1101 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
6fc6879b
JM		 1102 } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1103 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
f049052b 1104 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
6fc6879b 1105#endif /* CONFIG_IEEE80211R */
c10347f2
JM		 1106#ifdef CONFIG_SAE
1107 } else if (sel & WPA_KEY_MGMT_SAE) {
1108 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1109 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1110 } else if (sel & WPA_KEY_MGMT_FT_SAE) {
1111 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1112 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1113#endif /* CONFIG_SAE */
56586197
JM		 1114#ifdef CONFIG_IEEE80211W
1115 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1116 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
f049052b 1117 wpa_dbg(wpa_s, MSG_DEBUG,
56586197
JM		 1118 "WPA: using KEY_MGMT 802.1X with SHA256");
1119 } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1120 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
f049052b 1121 wpa_dbg(wpa_s, MSG_DEBUG,
56586197
JM		 1122 "WPA: using KEY_MGMT PSK with SHA256");
1123#endif /* CONFIG_IEEE80211W */
6fc6879b
JM		 1124 } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1125 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
f049052b 1126 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
6fc6879b
JM		 1127 } else if (sel & WPA_KEY_MGMT_PSK) {
1128 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
f049052b 1129 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
6fc6879b
JM		 1130 } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1131 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
f049052b 1132 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
df0f01d9
JM		 1133#ifdef CONFIG_HS20
1134 } else if (sel & WPA_KEY_MGMT_OSEN) {
1135 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1136 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1137#endif /* CONFIG_HS20 */
6fc6879b 1138 } else {
f049052b
BG		 1139 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1140 "authenticated key management type");
6fc6879b
JM		 1141 return -1;
1142 }
1143
1144 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1145 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1146 wpa_s->pairwise_cipher);
1147 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1148
1149#ifdef CONFIG_IEEE80211W
1150 sel = ie.mgmt_group_cipher;
62d49803
JM		 1151 if ((ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1152 wpa_s->conf->pmf : ssid->ieee80211w) == NO_MGMT_FRAME_PROTECTION ||
0b60b0aa 1153 !(ie.capabilities & WPA_CAPABILITY_MFPC))
6fc6879b
JM		 1154 sel = 0;
1155 if (sel & WPA_CIPHER_AES_128_CMAC) {
1156 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
f049052b 1157 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
6fc6879b 1158 "AES-128-CMAC");
8dd9f9cd
JM		 1159 } else if (sel & WPA_CIPHER_BIP_GMAC_128) {
1160 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1161 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1162 "BIP-GMAC-128");
1163 } else if (sel & WPA_CIPHER_BIP_GMAC_256) {
1164 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1165 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1166 "BIP-GMAC-256");
1167 } else if (sel & WPA_CIPHER_BIP_CMAC_256) {
1168 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1169 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1170 "BIP-CMAC-256");
6fc6879b
JM		 1171 } else {
1172 wpa_s->mgmt_group_cipher = 0;
f049052b 1173 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
6fc6879b
JM		 1174 }
1175 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1176 wpa_s->mgmt_group_cipher);
62d49803
JM		 1177 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1178 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1179 wpa_s->conf->pmf : ssid->ieee80211w));
6fc6879b
JM		 1180#endif /* CONFIG_IEEE80211W */
1181
1182 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
f049052b 1183 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
6fc6879b
JM		 1184 return -1;
1185 }
1186
0bf927a0 1187 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
bc26ac50 1188 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL);
7d232e23
ZC		 1189#ifndef CONFIG_NO_PBKDF2
1190 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1191 ssid->passphrase) {
1192 u8 psk[PMK_LEN];
986de33d
JM		 1193 pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len,
1194 4096, psk, PMK_LEN);
7d232e23
ZC		 1195 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1196 psk, PMK_LEN);
bc26ac50 1197 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL);
7d232e23
ZC		 1198 }
1199#endif /* CONFIG_NO_PBKDF2 */
9173b16f
JM		 1200#ifdef CONFIG_EXT_PASSWORD
1201 if (ssid->ext_psk) {
1202 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1203 ssid->ext_psk);
1204 char pw_str[64 + 1];
1205 u8 psk[PMK_LEN];
1206
1207 if (pw == NULL) {
1208 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1209 "found from external storage");
1210 return -1;
1211 }
1212
1213 if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) {
1214 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1215 "PSK length %d in external storage",
1216 (int) wpabuf_len(pw));
1217 ext_password_free(pw);
1218 return -1;
1219 }
1220
1221 os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw));
1222 pw_str[wpabuf_len(pw)] = '\0';
1223
1224#ifndef CONFIG_NO_PBKDF2
1225 if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss)
1226 {
986de33d
JM		 1227 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len,
1228 4096, psk, PMK_LEN);
9173b16f
JM		 1229 os_memset(pw_str, 0, sizeof(pw_str));
1230 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from "
1231 "external passphrase)",
1232 psk, PMK_LEN);
bc26ac50 1233 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL);
9173b16f
JM		 1234 } else
1235#endif /* CONFIG_NO_PBKDF2 */
1236 if (wpabuf_len(pw) == 2 * PMK_LEN) {
1237 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) {
1238 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1239 "Invalid PSK hex string");
1240 os_memset(pw_str, 0, sizeof(pw_str));
1241 ext_password_free(pw);
1242 return -1;
1243 }
bc26ac50 1244 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL);
9173b16f
JM		 1245 } else {
1246 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1247 "PSK available");
1248 os_memset(pw_str, 0, sizeof(pw_str));
1249 ext_password_free(pw);
1250 return -1;
1251 }
1252
1253 os_memset(pw_str, 0, sizeof(pw_str));
1254 ext_password_free(pw);
1255 }
1256#endif /* CONFIG_EXT_PASSWORD */
7d232e23 1257 } else
6fc6879b
JM		 1258 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1259
1260 return 0;
1261}
1262
1263
8cd6b7bc 1264static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
03e47c9c 1265{
8cd6b7bc 1266 *pos = 0x00;
03e47c9c 1267
8cd6b7bc
JB		 1268 switch (idx) {
1269 case 0: /* Bits 0-7 */
1270 break;
1271 case 1: /* Bits 8-15 */
1272 break;
1273 case 2: /* Bits 16-23 */
1274#ifdef CONFIG_WNM
1275 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */
1276 *pos |= 0x08; /* Bit 19 - BSS Transition */
1277#endif /* CONFIG_WNM */
1278 break;
1279 case 3: /* Bits 24-31 */
1280#ifdef CONFIG_WNM
1281 *pos |= 0x02; /* Bit 25 - SSID List */
1282#endif /* CONFIG_WNM */
03e47c9c 1283#ifdef CONFIG_INTERWORKING
8cd6b7bc
JB		 1284 if (wpa_s->conf->interworking)
1285 *pos |= 0x80; /* Bit 31 - Interworking */
03e47c9c 1286#endif /* CONFIG_INTERWORKING */
8cd6b7bc
JB		 1287 break;
1288 case 4: /* Bits 32-39 */
56f5af48 1289#ifdef CONFIG_INTERWORKING
429dd9af
JM		 1290 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1291 *pos |= 0x01; /* Bit 32 - QoS Map */
56f5af48 1292#endif /* CONFIG_INTERWORKING */
8cd6b7bc
JB		 1293 break;
1294 case 5: /* Bits 40-47 */
95a3ea94
JM		 1295#ifdef CONFIG_HS20
1296 if (wpa_s->conf->hs20)
1297 *pos |= 0x40; /* Bit 46 - WNM-Notification */
1298#endif /* CONFIG_HS20 */
8cd6b7bc
JB		 1299 break;
1300 case 6: /* Bits 48-55 */
1301 break;
1302 }
1303}
03e47c9c 1304
03e47c9c 1305
0bbaa9b9 1306int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
8cd6b7bc
JB		 1307{
1308 u8 *pos = buf;
95a3ea94 1309 u8 len = 6, i;
8cd6b7bc
JB		 1310
1311 if (len < wpa_s->extended_capa_len)
1312 len = wpa_s->extended_capa_len;
0bbaa9b9
JM		 1313 if (buflen < (size_t) len + 2) {
1314 wpa_printf(MSG_INFO,
1315 "Not enough room for building extended capabilities element");
1316 return -1;
1317 }
03e47c9c
JM		 1318
1319 *pos++ = WLAN_EID_EXT_CAPAB;
8cd6b7bc
JB		 1320 *pos++ = len;
1321 for (i = 0; i < len; i++, pos++) {
1322 wpas_ext_capab_byte(wpa_s, pos, i);
1323
1324 if (i < wpa_s->extended_capa_len) {
1325 *pos &= ~wpa_s->extended_capa_mask[i];
1326 *pos |= wpa_s->extended_capa[i];
1327 }
1328 }
03e47c9c 1329
3db5439a
JM		 1330 while (len > 0 && buf[1 + len] == 0) {
1331 len--;
1332 buf[1] = len;
1333 }
1334 if (len == 0)
1335 return 0;
1336
1337 return 2 + len;
03e47c9c
JM		 1338}
1339
1340
6ac4b15e
JM		 1341static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1342 struct wpa_bss *test_bss)
1343{
1344 struct wpa_bss *bss;
1345
1346 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1347 if (bss == test_bss)
1348 return 1;
1349 }
1350
1351 return 0;
1352}
1353
1354
1355static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1356 struct wpa_ssid *test_ssid)
1357{
1358 struct wpa_ssid *ssid;
1359
1360 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1361 if (ssid == test_ssid)
1362 return 1;
1363 }
1364
1365 return 0;
1366}
1367
1368
1369int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1370 struct wpa_ssid *test_ssid)
1371{
1372 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1373 return 0;
1374
1375 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1376}
1377
1378
1379void wpas_connect_work_free(struct wpa_connect_work *cwork)
1380{
1381 if (cwork == NULL)
1382 return;
1383 os_free(cwork);
1384}
1385
1386
1387void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1388{
1389 struct wpa_connect_work *cwork;
1390 struct wpa_radio_work *work = wpa_s->connect_work;
1391
1392 if (!work)
1393 return;
1394
1395 wpa_s->connect_work = NULL;
1396 cwork = work->ctx;
1397 work->ctx = NULL;
1398 wpas_connect_work_free(cwork);
1399 radio_work_done(work);
1400}
1401
1402
a313d17d 1403int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
c267753b
JM		 1404{
1405 struct os_reltime now;
1406 u8 addr[ETH_ALEN];
1407
1408 os_get_reltime(&now);
a313d17d
JM		 1409 if (wpa_s->last_mac_addr_style == style &&
1410 wpa_s->last_mac_addr_change.sec != 0 &&
c267753b
JM		 1411 !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1412 wpa_s->conf->rand_addr_lifetime)) {
1413 wpa_msg(wpa_s, MSG_DEBUG,
1414 "Previously selected random MAC address has not yet expired");
1415 return 0;
1416 }
1417
a313d17d
JM		 1418 switch (style) {
1419 case 1:
1420 if (random_mac_addr(addr) < 0)
1421 return -1;
1422 break;
1423 case 2:
1424 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1425 if (random_mac_addr_keep_oui(addr) < 0)
1426 return -1;
1427 break;
1428 default:
c267753b 1429 return -1;
a313d17d 1430 }
c267753b
JM		 1431
1432 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1433 wpa_msg(wpa_s, MSG_INFO,
1434 "Failed to set random MAC address");
1435 return -1;
1436 }
1437
1438 os_get_reltime(&wpa_s->last_mac_addr_change);
1439 wpa_s->mac_addr_changed = 1;
a313d17d 1440 wpa_s->last_mac_addr_style = style;
c267753b
JM		 1441
1442 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1443 wpa_msg(wpa_s, MSG_INFO,
1444 "Could not update MAC address information");
1445 return -1;
1446 }
1447
1448 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1449 MAC2STR(addr));
1450
1451 return 0;
1452}
1453
1454
1455int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1456{
1457 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1458 !wpa_s->conf->preassoc_mac_addr)
1459 return 0;
1460
a313d17d 1461 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
c267753b
JM		 1462}
1463
1464
6ac4b15e
JM		 1465static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit);
1466
6fc6879b
JM		 1467/**
1468 * wpa_supplicant_associate - Request association
1469 * @wpa_s: Pointer to wpa_supplicant data
1470 * @bss: Scan results for the selected BSS, or %NULL if not available
1471 * @ssid: Configuration data for the selected network
1472 *
1473 * This function is used to request %wpa_supplicant to associate with a BSS.
1474 */
1475void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
6fa81a3b 1476 struct wpa_bss *bss, struct wpa_ssid *ssid)
6fc6879b 1477{
6ac4b15e 1478 struct wpa_connect_work *cwork;
a313d17d
JM		 1479 int rand_style;
1480
1481 if (ssid->mac_addr == -1)
1482 rand_style = wpa_s->conf->mac_addr;
1483 else
1484 rand_style = ssid->mac_addr;
6fc6879b 1485
c267753b
JM		 1486 if (wpa_s->last_ssid == ssid) {
1487 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
a313d17d
JM		 1488 } else if (rand_style > 0) {
1489 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
c267753b
JM		 1490 return;
1491 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1492 } else if (wpa_s->mac_addr_changed) {
1493 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1494 wpa_msg(wpa_s, MSG_INFO,
1495 "Could not restore permanent MAC address");
1496 return;
1497 }
1498 wpa_s->mac_addr_changed = 0;
1499 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1500 wpa_msg(wpa_s, MSG_INFO,
1501 "Could not update MAC address information");
1502 return;
1503 }
1504 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1505 }
1506 wpa_s->last_ssid = ssid;
1507
78177a00
JM		 1508#ifdef CONFIG_IBSS_RSN
1509 ibss_rsn_deinit(wpa_s->ibss_rsn);
1510 wpa_s->ibss_rsn = NULL;
1511#endif /* CONFIG_IBSS_RSN */
1512
2c5d725c
JM		 1513 if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1514 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1581b38b
JM		 1515#ifdef CONFIG_AP
1516 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
f049052b
BG		 1517 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1518 "mode");
1581b38b
JM		 1519 return;
1520 }
8c981d17
DW		 1521 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1522 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
b2b688d1
VKE		 1523 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
1524 wpas_p2p_ap_setup_failed(wpa_s);
8c981d17
DW		 1525 return;
1526 }
8f770587 1527 wpa_s->current_bss = bss;
1581b38b 1528#else /* CONFIG_AP */
f049052b
BG		 1529 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1530 "the build");
1581b38b
JM		 1531#endif /* CONFIG_AP */
1532 return;
1533 }
1534
52c9e6f3 1535#ifdef CONFIG_TDLS
95cb2d88
JM		 1536 if (bss)
1537 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1538 bss->ie_len);
52c9e6f3
JM		 1539#endif /* CONFIG_TDLS */
1540
5cc4d64b
JM		 1541 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1542 ssid->mode == IEEE80211_MODE_INFRA) {
c2a04078
JM		 1543 sme_authenticate(wpa_s, bss, ssid);
1544 return;
1545 }
1546
6ac4b15e
JM		 1547 if (wpa_s->connect_work) {
1548 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1549 return;
1550 }
1551
f0e30c84
JM		 1552 if (radio_work_pending(wpa_s, "connect")) {
1553 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1554 return;
1555 }
1556
6ac4b15e
JM		 1557 cwork = os_zalloc(sizeof(*cwork));
1558 if (cwork == NULL)
1559 return;
1560
1561 cwork->bss = bss;
1562 cwork->ssid = ssid;
1563
1564 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1565 wpas_start_assoc_cb, cwork) < 0) {
1566 os_free(cwork);
1567 }
1568}
1569
1570
1571static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
1572{
1573 struct wpa_connect_work *cwork = work->ctx;
1574 struct wpa_bss *bss = cwork->bss;
1575 struct wpa_ssid *ssid = cwork->ssid;
1576 struct wpa_supplicant *wpa_s = work->wpa_s;
1577 u8 wpa_ie[200];
1578 size_t wpa_ie_len;
1579 int use_crypt, ret, i, bssid_changed;
1580 int algs = WPA_AUTH_ALG_OPEN;
1581 unsigned int cipher_pairwise, cipher_group;
1582 struct wpa_driver_associate_params params;
1583 int wep_keys_set = 0;
1584 int assoc_failed = 0;
1585 struct wpa_ssid *old_ssid;
1586#ifdef CONFIG_HT_OVERRIDES
1587 struct ieee80211_ht_capabilities htcaps;
1588 struct ieee80211_ht_capabilities htcaps_mask;
1589#endif /* CONFIG_HT_OVERRIDES */
6aa1cd4e
PS		 1590#ifdef CONFIG_VHT_OVERRIDES
1591 struct ieee80211_vht_capabilities vhtcaps;
1592 struct ieee80211_vht_capabilities vhtcaps_mask;
1593#endif /* CONFIG_VHT_OVERRIDES */
6ac4b15e
JM		 1594
1595 if (deinit) {
b3253ebb
AO		 1596 if (work->started) {
1597 wpa_s->connect_work = NULL;
1598
1599 /* cancel possible auth. timeout */
1600 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
1601 NULL);
1602 }
6ac4b15e
JM		 1603 wpas_connect_work_free(cwork);
1604 return;
1605 }
1606
1607 wpa_s->connect_work = work;
1608
a7f5271d 1609 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid)) {
6ac4b15e
JM		 1610 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
1611 wpas_connect_work_done(wpa_s);
1612 return;
1613 }
1614
0c80427d 1615 os_memset(&params, 0, sizeof(params));
6fc6879b 1616 wpa_s->reassociate = 0;
c60ba9f7 1617 wpa_s->eap_expected_failure = 0;
76d81b32
JM		 1618 if (bss &&
1619 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
6fc6879b 1620#ifdef CONFIG_IEEE80211R
6fa81a3b 1621 const u8 *ie, *md = NULL;
6fc6879b 1622#endif /* CONFIG_IEEE80211R */
6fc6879b
JM		 1623 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1624 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
6fa81a3b 1625 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
8bac466b 1626 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
6fc6879b
JM		 1627 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1628 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
8bac466b
JM		 1629 if (bssid_changed)
1630 wpas_notify_bssid_changed(wpa_s);
6fc6879b 1631#ifdef CONFIG_IEEE80211R
6fa81a3b 1632 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
6fc6879b
JM		 1633 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1634 md = ie + 2;
e7846b68 1635 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
91a05482
JM		 1636 if (md) {
1637 /* Prepare for the next transition */
76b7981d 1638 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
91a05482 1639 }
6fc6879b 1640#endif /* CONFIG_IEEE80211R */
24c23d1b
JM		 1641#ifdef CONFIG_WPS
1642 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1643 wpa_s->conf->ap_scan == 2 &&
1644 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1645 /* Use ap_scan==1 style network selection to find the network
1646 */
74656400 1647 wpas_connect_work_done(wpa_s);
4115303b 1648 wpa_s->scan_req = MANUAL_SCAN_REQ;
24c23d1b
JM		 1649 wpa_s->reassociate = 1;
1650 wpa_supplicant_req_scan(wpa_s, 0, 0);
1651 return;
1652#endif /* CONFIG_WPS */
6fc6879b
JM		 1653 } else {
1654 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1655 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1656 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1657 }
a4cba8f1 1658 wpa_supplicant_cancel_sched_scan(wpa_s);
6fc6879b
JM		 1659 wpa_supplicant_cancel_scan(wpa_s);
1660
1661 /* Starting new association, so clear the possibly used WPA IE from the
1662 * previous association. */
1663 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1664
1665#ifdef IEEE8021X_EAPOL
1666 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1667 if (ssid->leap) {
1668 if (ssid->non_leap == 0)
abd9fafa 1669 algs = WPA_AUTH_ALG_LEAP;
6fc6879b 1670 else
abd9fafa 1671 algs |= WPA_AUTH_ALG_LEAP;
6fc6879b
JM		 1672 }
1673 }
1674#endif /* IEEE8021X_EAPOL */
f049052b 1675 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
6fc6879b 1676 if (ssid->auth_alg) {
abd9fafa 1677 algs = ssid->auth_alg;
f049052b
BG		 1678 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1679 "0x%x", algs);
6fc6879b 1680 }
6fc6879b 1681
6fa81a3b
JM		 1682 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1683 wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
0bf927a0 1684 wpa_key_mgmt_wpa(ssid->key_mgmt)) {
6fc6879b 1685 int try_opportunistic;
6e202021
JM		 1686 try_opportunistic = (ssid->proactive_key_caching < 0 ?
1687 wpa_s->conf->okc :
1688 ssid->proactive_key_caching) &&
6fc6879b
JM		 1689 (ssid->proto & WPA_PROTO_RSN);
1690 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
b2a12c4f 1691 ssid, try_opportunistic) == 0)
6fc6879b
JM		 1692 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1693 wpa_ie_len = sizeof(wpa_ie);
1694 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1695 wpa_ie, &wpa_ie_len)) {
f049052b
BG		 1696 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1697 "key management and encryption suites");
74656400 1698 wpas_connect_work_done(wpa_s);
6fc6879b
JM		 1699 return;
1700 }
a3f7e518
JM		 1701 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
1702 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
1703 /*
1704 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
1705 * use non-WPA since the scan results did not indicate that the
1706 * AP is using WPA or WPA2.
1707 */
1708 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1709 wpa_ie_len = 0;
1710 wpa_s->wpa_proto = 0;
0bf927a0 1711 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
6fc6879b
JM		 1712 wpa_ie_len = sizeof(wpa_ie);
1713 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1714 wpa_ie, &wpa_ie_len)) {
f049052b
BG		 1715 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1716 "key management and encryption suites (no "
1717 "scan results)");
74656400 1718 wpas_connect_work_done(wpa_s);
6fc6879b
JM		 1719 return;
1720 }
ad08c363
JM		 1721#ifdef CONFIG_WPS
1722 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
b01c18a8
JM		 1723 struct wpabuf *wps_ie;
1724 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
ad08c363
JM		 1725 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1726 wpa_ie_len = wpabuf_len(wps_ie);
1727 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
24386985
JM		 1728 } else
1729 wpa_ie_len = 0;
ad08c363
JM		 1730 wpabuf_free(wps_ie);
1731 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
0c80427d
JM		 1732 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1733 params.wps = WPS_MODE_PRIVACY;
1734 else
1735 params.wps = WPS_MODE_OPEN;
cf546f1a 1736 wpa_s->wpa_proto = 0;
ad08c363 1737#endif /* CONFIG_WPS */
6fc6879b
JM		 1738 } else {
1739 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1740 wpa_ie_len = 0;
cf546f1a 1741 wpa_s->wpa_proto = 0;
6fc6879b
JM		 1742 }
1743
5f3a6aa0
JM		 1744#ifdef CONFIG_P2P
1745 if (wpa_s->global->p2p) {
1746 u8 *pos;
1747 size_t len;
1748 int res;
5f3a6aa0
JM		 1749 pos = wpa_ie + wpa_ie_len;
1750 len = sizeof(wpa_ie) - wpa_ie_len;
b8a8d677
JM		 1751 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1752 ssid->p2p_group);
5f3a6aa0
JM		 1753 if (res >= 0)
1754 wpa_ie_len += res;
1755 }
72044390
JM		 1756
1757 wpa_s->cross_connect_disallowed = 0;
1758 if (bss) {
1759 struct wpabuf *p2p;
1760 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1761 if (p2p) {
1762 wpa_s->cross_connect_disallowed =
1763 p2p_get_cross_connect_disallowed(p2p);
1764 wpabuf_free(p2p);
f049052b
BG		 1765 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1766 "connection",
1767 wpa_s->cross_connect_disallowed ?
1768 "disallows" : "allows");
72044390
JM		 1769 }
1770 }
25ef8529
JM		 1771
1772 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
5f3a6aa0
JM		 1773#endif /* CONFIG_P2P */
1774
cb418324 1775#ifdef CONFIG_HS20
55a2df43 1776 if (is_hs20_network(wpa_s, ssid, bss)) {
cb418324
JM		 1777 struct wpabuf *hs20;
1778 hs20 = wpabuf_alloc(20);
1779 if (hs20) {
f9cd147d 1780 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
745ef184
JM		 1781 size_t len;
1782
f9cd147d 1783 wpas_hs20_add_indication(hs20, pps_mo_id);
745ef184
JM		 1784 len = sizeof(wpa_ie) - wpa_ie_len;
1785 if (wpabuf_len(hs20) <= len) {
1786 os_memcpy(wpa_ie + wpa_ie_len,
1787 wpabuf_head(hs20), wpabuf_len(hs20));
1788 wpa_ie_len += wpabuf_len(hs20);
1789 }
cb418324
JM		 1790 wpabuf_free(hs20);
1791 }
1792 }
1793#endif /* CONFIG_HS20 */
1794
8b3b803a
AH		 1795 /*
1796 * Workaround: Add Extended Capabilities element only if the AP
1797 * included this element in Beacon/Probe Response frames. Some older
1798 * APs seem to have interoperability issues if this element is
1799 * included, so while the standard may require us to include the
1800 * element in all cases, it is justifiable to skip it to avoid
1801 * interoperability issues.
1802 */
1803 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
0bbaa9b9 1804 u8 ext_capab[18];
8b3b803a 1805 int ext_capab_len;
0bbaa9b9
JM		 1806 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
1807 sizeof(ext_capab));
8b3b803a
AH		 1808 if (ext_capab_len > 0) {
1809 u8 *pos = wpa_ie;
1810 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
1811 pos += 2 + pos[1];
1812 os_memmove(pos + ext_capab_len, pos,
1813 wpa_ie_len - (pos - wpa_ie));
1814 wpa_ie_len += ext_capab_len;
1815 os_memcpy(pos, ext_capab, ext_capab_len);
1816 }
92cbcf91 1817 }
92cbcf91 1818
6fc6879b
JM		 1819 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1820 use_crypt = 1;
4848a38d
JM		 1821 cipher_pairwise = wpa_s->pairwise_cipher;
1822 cipher_group = wpa_s->group_cipher;
6fc6879b
JM		 1823 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1824 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1825 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1826 use_crypt = 0;
1827 if (wpa_set_wep_keys(wpa_s, ssid)) {
1828 use_crypt = 1;
1829 wep_keys_set = 1;
1830 }
1831 }
ad08c363
JM		 1832 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1833 use_crypt = 0;
6fc6879b
JM		 1834
1835#ifdef IEEE8021X_EAPOL
1836 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1837 if ((ssid->eapol_flags &
1838 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1839 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1840 !wep_keys_set) {
1841 use_crypt = 0;
1842 } else {
1843 /* Assume that dynamic WEP-104 keys will be used and
1844 * set cipher suites in order for drivers to expect
1845 * encryption. */
4848a38d 1846 cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
6fc6879b
JM		 1847 }
1848 }
1849#endif /* IEEE8021X_EAPOL */
1850
1851 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1852 /* Set the key before (and later after) association */
1853 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1854 }
1855
6fc6879b 1856 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
6fc6879b 1857 if (bss) {
6fa81a3b
JM		 1858 params.ssid = bss->ssid;
1859 params.ssid_len = bss->ssid_len;
f15854d1
JM		 1860 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1861 wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
1862 MACSTR " freq=%u MHz based on scan results "
1863 "(bssid_set=%d)",
1864 MAC2STR(bss->bssid), bss->freq,
1865 ssid->bssid_set);
22628eca 1866 params.bssid = bss->bssid;
4ec68377 1867 params.freq.freq = bss->freq;
22628eca 1868 }
7ac7fd43
DS		 1869 params.bssid_hint = bss->bssid;
1870 params.freq_hint = bss->freq;
6fc6879b
JM		 1871 } else {
1872 params.ssid = ssid->ssid;
1873 params.ssid_len = ssid->ssid_len;
1874 }
9e2af29f
NC		 1875
1876 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
1877 wpa_s->conf->ap_scan == 2) {
1878 params.bssid = ssid->bssid;
1879 params.fixed_bssid = 1;
1880 }
1881
d7dcba70 1882 if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
dc152f32
JD		 1883 params.freq.freq == 0) {
1884 enum hostapd_hw_mode hw_mode;
1885 u8 channel;
1886
4ec68377 1887 params.freq.freq = ssid->frequency;
8f05577d 1888
dc152f32
JD		 1889 hw_mode = ieee80211_freq_to_chan(ssid->frequency, &channel);
1890 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1891 if (wpa_s->hw.modes[i].mode == hw_mode) {
1892 struct hostapd_hw_modes *mode;
1893
1894 mode = &wpa_s->hw.modes[i];
1895 params.freq.ht_enabled = ht_supported(mode);
1896 break;
1897 }
1898 }
1899 }
1900
8f05577d
JM		 1901 if (ssid->mode == WPAS_MODE_IBSS) {
1902 if (ssid->beacon_int)
1903 params.beacon_int = ssid->beacon_int;
1904 else
1905 params.beacon_int = wpa_s->conf->beacon_int;
1906 }
1907
6fc6879b
JM		 1908 params.wpa_ie = wpa_ie;
1909 params.wpa_ie_len = wpa_ie_len;
1910 params.pairwise_suite = cipher_pairwise;
1911 params.group_suite = cipher_group;
4848a38d 1912 params.key_mgmt_suite = wpa_s->key_mgmt;
64fa840a 1913 params.wpa_proto = wpa_s->wpa_proto;
6fc6879b
JM		 1914 params.auth_alg = algs;
1915 params.mode = ssid->mode;
1f6c0ab8 1916 params.bg_scan_period = ssid->bg_scan_period;
6fc6879b
JM		 1917 for (i = 0; i < NUM_WEP_KEYS; i++) {
1918 if (ssid->wep_key_len[i])
1919 params.wep_key[i] = ssid->wep_key[i];
1920 params.wep_key_len[i] = ssid->wep_key_len[i];
1921 }
1922 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1923
c2a04078 1924 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
4848a38d
JM		 1925 (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
1926 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
6fc6879b
JM		 1927 params.passphrase = ssid->passphrase;
1928 if (ssid->psk_set)
1929 params.psk = ssid->psk;
b41f2684
CL		 1930 }
1931
1932 if (wpa_s->conf->key_mgmt_offload) {
1933 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
666497c8
JM		 1934 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
1935 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B)
b41f2684
CL		 1936 params.req_key_mgmt_offload =
1937 ssid->proactive_key_caching < 0 ?
1938 wpa_s->conf->okc : ssid->proactive_key_caching;
1939 else
1940 params.req_key_mgmt_offload = 1;
1941
1942 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
1943 params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
1944 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
1945 ssid->psk_set)
1946 params.psk = ssid->psk;
6fc6879b
JM		 1947 }
1948
36b15723
JM		 1949 params.drop_unencrypted = use_crypt;
1950
6fc6879b 1951#ifdef CONFIG_IEEE80211W
62d49803
JM		 1952 params.mgmt_frame_protection =
1953 ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1954 wpa_s->conf->pmf : ssid->ieee80211w;
1955 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
6fa81a3b 1956 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
97d3497e
JM		 1957 struct wpa_ie_data ie;
1958 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1959 ie.capabilities &
1960 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
f049052b
BG		 1961 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1962 "MFP: require MFP");
97d3497e
JM		 1963 params.mgmt_frame_protection =
1964 MGMT_FRAME_PROTECTION_REQUIRED;
1965 }
1966 }
6fc6879b
JM		 1967#endif /* CONFIG_IEEE80211W */
1968
ffad8858 1969 params.p2p = ssid->p2p_group;
6e3f4b89 1970
eea2fd9e
JM		 1971 if (wpa_s->parent->set_sta_uapsd)
1972 params.uapsd = wpa_s->parent->sta_uapsd;
1973 else
1974 params.uapsd = -1;
1975
80e8a5ee
BG		 1976#ifdef CONFIG_HT_OVERRIDES
1977 os_memset(&htcaps, 0, sizeof(htcaps));
1978 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
1979 params.htcaps = (u8 *) &htcaps;
1980 params.htcaps_mask = (u8 *) &htcaps_mask;
1981 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
1982#endif /* CONFIG_HT_OVERRIDES */
6aa1cd4e
PS		 1983#ifdef CONFIG_VHT_OVERRIDES
1984 os_memset(&vhtcaps, 0, sizeof(vhtcaps));
1985 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
1986 params.vhtcaps = &vhtcaps;
1987 params.vhtcaps_mask = &vhtcaps_mask;
1988 wpa_supplicant_apply_vht_overrides(wpa_s, wpa_s->current_ssid, &params);
1989#endif /* CONFIG_VHT_OVERRIDES */
80e8a5ee 1990
8567866d
JJ		 1991#ifdef CONFIG_P2P
1992 /*
1993 * If multi-channel concurrency is not supported, check for any
1994 * frequency conflict. In case of any frequency conflict, remove the
1995 * least prioritized connection.
1996 */
1997 if (wpa_s->num_multichan_concurrent < 2) {
d0df6437
IP		 1998 int freq, num;
1999 num = get_shared_radio_freqs(wpa_s, &freq, 1);
4ec68377 2000 if (num > 0 && freq > 0 && freq != params.freq.freq) {
d0df6437
IP		 2001 wpa_printf(MSG_DEBUG,
2002 "Assoc conflicting freq found (%d != %d)",
4ec68377
JD		 2003 freq, params.freq.freq);
2004 if (wpas_p2p_handle_frequency_conflicts(
74656400
SD		 2005 wpa_s, params.freq.freq, ssid) < 0) {
2006 wpas_connect_work_done(wpa_s);
8567866d 2007 return;
74656400 2008 }
8567866d
JJ		 2009 }
2010 }
2011#endif /* CONFIG_P2P */
2012
17fbb751 2013 ret = wpa_drv_associate(wpa_s, &params);
6fc6879b
JM		 2014 if (ret < 0) {
2015 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2016 "failed");
871f4dd0
JM		 2017 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2018 /*
2019 * The driver is known to mean what is saying, so we
2020 * can stop right here; the association will not
2021 * succeed.
2022 */
2023 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
c1c02342 2024 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
871f4dd0
JM		 2025 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2026 return;
2027 }
6fc6879b
JM		 2028 /* try to continue anyway; new association will be tried again
2029 * after timeout */
2030 assoc_failed = 1;
2031 }
2032
2033 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2034 /* Set the key after the association just in case association
2035 * cleared the previously configured key. */
2036 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2037 /* No need to timeout authentication since there is no key
2038 * management. */
2039 wpa_supplicant_cancel_auth_timeout(wpa_s);
2040 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
53895c3b 2041#ifdef CONFIG_IBSS_RSN
d7dcba70 2042 } else if (ssid->mode == WPAS_MODE_IBSS &&
53895c3b
JM		 2043 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2044 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2045 /*
2046 * RSN IBSS authentication is per-STA and we can disable the
2047 * per-BSSID authentication.
2048 */
2049 wpa_supplicant_cancel_auth_timeout(wpa_s);
53895c3b 2050#endif /* CONFIG_IBSS_RSN */
6fc6879b
JM		 2051 } else {
2052 /* Timeout for IEEE 802.11 authentication and association */
1d3c75b3
DW		 2053 int timeout = 60;
2054
2055 if (assoc_failed) {
2056 /* give IBSS a bit more time */
d7dcba70 2057 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
1d3c75b3
DW		 2058 } else if (wpa_s->conf->ap_scan == 1) {
2059 /* give IBSS a bit more time */
d7dcba70 2060 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
1d3c75b3 2061 }
6fc6879b
JM		 2062 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2063 }
2064
66562e9c
JM		 2065 if (wep_keys_set &&
2066 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
6fc6879b
JM		 2067 /* Set static WEP keys again */
2068 wpa_set_wep_keys(wpa_s, ssid);
2069 }
2070
2071 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2072 /*
2073 * Do not allow EAP session resumption between different
2074 * network configurations.
2075 */
2076 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2077 }
8bac466b 2078 old_ssid = wpa_s->current_ssid;
6fc6879b 2079 wpa_s->current_ssid = ssid;
8f770587 2080 wpa_s->current_bss = bss;
6fc6879b
JM		 2081 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2082 wpa_supplicant_initiate_eapol(wpa_s);
8bac466b
JM		 2083 if (old_ssid != wpa_s->current_ssid)
2084 wpas_notify_network_changed(wpa_s);
6fc6879b
JM		 2085}
2086
2087
09f58c09
JM		 2088static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2089 const u8 *addr)
2090{
2091 struct wpa_ssid *old_ssid;
2092
c155305f 2093 wpas_connect_work_done(wpa_s);
09f58c09 2094 wpa_clear_keys(wpa_s, addr);
09f58c09 2095 old_ssid = wpa_s->current_ssid;
0d30cc24 2096 wpa_supplicant_mark_disassoc(wpa_s);
09f58c09
JM		 2097 wpa_sm_set_config(wpa_s->wpa, NULL);
2098 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2099 if (old_ssid != wpa_s->current_ssid)
2100 wpas_notify_network_changed(wpa_s);
2101 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2102}
2103
2104
6fc6879b
JM		 2105/**
2106 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2107 * @wpa_s: Pointer to wpa_supplicant data
2108 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2109 *
073ab58f 2110 * This function is used to request %wpa_supplicant to deauthenticate from the
6fc6879b
JM		 2111 * current AP.
2112 */
2113void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2114 int reason_code)
2115{
2116 u8 *addr = NULL;
ef48ff94 2117 union wpa_event_data event;
42d23547 2118 int zero_addr = 0;
8bac466b 2119
42d23547
JM		 2120 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2121 " pending_bssid=" MACSTR " reason=%d state=%s",
2122 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2123 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2124
2125 if (!is_zero_ether_addr(wpa_s->bssid))
2126 addr = wpa_s->bssid;
2127 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2128 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2129 wpa_s->wpa_state == WPA_ASSOCIATING))
2130 addr = wpa_s->pending_bssid;
2131 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2132 /*
2133 * When using driver-based BSS selection, we may not know the
2134 * BSSID with which we are currently trying to associate. We
2135 * need to notify the driver of this disconnection even in such
2136 * a case, so use the all zeros address here.
2137 */
6fc6879b 2138 addr = wpa_s->bssid;
42d23547
JM		 2139 zero_addr = 1;
2140 }
2141
7b44ff2c
SD		 2142#ifdef CONFIG_TDLS
2143 wpa_tdls_teardown_peers(wpa_s->wpa);
2144#endif /* CONFIG_TDLS */
2145
42d23547
JM		 2146 if (addr) {
2147 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
ef48ff94
JM		 2148 os_memset(&event, 0, sizeof(event));
2149 event.deauth_info.reason_code = (u16) reason_code;
2150 event.deauth_info.locally_generated = 1;
2151 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
42d23547
JM		 2152 if (zero_addr)
2153 addr = NULL;
6fc6879b 2154 }
09f58c09
JM		 2155
2156 wpa_supplicant_clear_connection(wpa_s, addr);
6fc6879b
JM		 2157}
2158
dca1a511
DS		 2159static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2160 struct wpa_ssid *ssid)
2161{
2162 if (!ssid || !ssid->disabled || ssid->disabled == 2)
2163 return;
2164
2165 ssid->disabled = 0;
2166 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2167 wpas_notify_network_enabled_changed(wpa_s, ssid);
2168
2169 /*
2170 * Try to reassociate since there is no current configuration and a new
2171 * network was made available.
2172 */
d2592497 2173 if (!wpa_s->current_ssid && !wpa_s->disconnected)
dca1a511
DS		 2174 wpa_s->reassociate = 1;
2175}
2176
6fc6879b 2177
86b89452
WS		 2178/**
2179 * wpa_supplicant_enable_network - Mark a configured network as enabled
2180 * @wpa_s: wpa_supplicant structure for a network interface
2181 * @ssid: wpa_ssid structure for a configured network or %NULL
2182 *
2183 * Enables the specified network or all networks if no network specified.
2184 */
2185void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2186 struct wpa_ssid *ssid)
2187{
86b89452 2188 if (ssid == NULL) {
14f79078
JM		 2189 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2190 wpa_supplicant_enable_one_network(wpa_s, ssid);
dca1a511
DS		 2191 } else
2192 wpa_supplicant_enable_one_network(wpa_s, ssid);
86b89452 2193
d2592497 2194 if (wpa_s->reassociate && !wpa_s->disconnected) {
dca1a511
DS		 2195 if (wpa_s->sched_scanning) {
2196 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
2197 "new network to scan filters");
2198 wpa_supplicant_cancel_sched_scan(wpa_s);
2199 }
86b89452 2200
dad153d1
JM		 2201 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2202 wpa_supplicant_req_scan(wpa_s, 0, 0);
86b89452
WS		 2203 }
2204}
2205
2206
2207/**
2208 * wpa_supplicant_disable_network - Mark a configured network as disabled
2209 * @wpa_s: wpa_supplicant structure for a network interface
2210 * @ssid: wpa_ssid structure for a configured network or %NULL
2211 *
2212 * Disables the specified network or all networks if no network specified.
2213 */
2214void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2215 struct wpa_ssid *ssid)
2216{
2217 struct wpa_ssid *other_ssid;
2218 int was_disabled;
2219
2220 if (ssid == NULL) {
725fc39e
DS		 2221 if (wpa_s->sched_scanning)
2222 wpa_supplicant_cancel_sched_scan(wpa_s);
2223
4dac0245
JM		 2224 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2225 other_ssid = other_ssid->next) {
86b89452 2226 was_disabled = other_ssid->disabled;
4dac0245
JM		 2227 if (was_disabled == 2)
2228 continue; /* do not change persistent P2P group
2229 * data */
86b89452
WS		 2230
2231 other_ssid->disabled = 1;
2232
2233 if (was_disabled != other_ssid->disabled)
2234 wpas_notify_network_enabled_changed(
2235 wpa_s, other_ssid);
86b89452
WS		 2236 }
2237 if (wpa_s->current_ssid)
07783eaa 2238 wpa_supplicant_deauthenticate(
86b89452 2239 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
4dac0245 2240 } else if (ssid->disabled != 2) {
86b89452 2241 if (ssid == wpa_s->current_ssid)
07783eaa 2242 wpa_supplicant_deauthenticate(
86b89452
WS		 2243 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2244
2245 was_disabled = ssid->disabled;
2246
2247 ssid->disabled = 1;
2248
725fc39e 2249 if (was_disabled != ssid->disabled) {
86b89452 2250 wpas_notify_network_enabled_changed(wpa_s, ssid);
725fc39e
DS		 2251 if (wpa_s->sched_scanning) {
2252 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
2253 "to remove network from filters");
2254 wpa_supplicant_cancel_sched_scan(wpa_s);
2255 wpa_supplicant_req_scan(wpa_s, 0, 0);
2256 }
2257 }
86b89452
WS		 2258 }
2259}
2260
2261
2262/**
2263 * wpa_supplicant_select_network - Attempt association with a network
2264 * @wpa_s: wpa_supplicant structure for a network interface
2265 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2266 */
2267void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2268 struct wpa_ssid *ssid)
2269{
2270
2271 struct wpa_ssid *other_ssid;
d93dfbd5 2272 int disconnected = 0;
86b89452 2273
d93dfbd5 2274 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
07783eaa 2275 wpa_supplicant_deauthenticate(
86b89452 2276 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
d93dfbd5
JM		 2277 disconnected = 1;
2278 }
86b89452 2279
00e5e3d5
JM		 2280 if (ssid)
2281 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2282
86b89452
WS		 2283 /*
2284 * Mark all other networks disabled or mark all networks enabled if no
2285 * network specified.
2286 */
4dac0245
JM		 2287 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2288 other_ssid = other_ssid->next) {
86b89452 2289 int was_disabled = other_ssid->disabled;
4dac0245
JM		 2290 if (was_disabled == 2)
2291 continue; /* do not change persistent P2P group data */
86b89452
WS		 2292
2293 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
00e5e3d5
JM		 2294 if (was_disabled && !other_ssid->disabled)
2295 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
86b89452
WS		 2296
2297 if (was_disabled != other_ssid->disabled)
2298 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
86b89452 2299 }
2a6f78fb
JJ		 2300
2301 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
2302 /* We are already associated with the selected network */
2303 wpa_printf(MSG_DEBUG, "Already associated with the "
2304 "selected network - do nothing");
2305 return;
2306 }
2307
25a8f9e3 2308 if (ssid) {
96efeeb6 2309 wpa_s->current_ssid = ssid;
25a8f9e3
JM		 2310 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2311 }
7dcdcfd6 2312 wpa_s->connect_without_scan = NULL;
86b89452
WS		 2313 wpa_s->disconnected = 0;
2314 wpa_s->reassociate = 1;
cecdddc1
PS		 2315
2316 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2317 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
86b89452 2318
a1641d26
JM		 2319 if (ssid)
2320 wpas_notify_network_selected(wpa_s, ssid);
86b89452
WS		 2321}
2322
2323
bdec7ee5
MS		 2324/**
2325 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
2326 * @wpa_s: wpa_supplicant structure for a network interface
2327 * @pkcs11_engine_path: PKCS #11 engine path or NULL
2328 * @pkcs11_module_path: PKCS #11 module path or NULL
2329 * Returns: 0 on success; -1 on failure
2330 *
2331 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
2332 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
2333 * module path fails the paths will be reset to the default value (NULL).
2334 */
2335int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
2336 const char *pkcs11_engine_path,
2337 const char *pkcs11_module_path)
2338{
2339 char *pkcs11_engine_path_copy = NULL;
2340 char *pkcs11_module_path_copy = NULL;
2341
2342 if (pkcs11_engine_path != NULL) {
2343 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
2344 if (pkcs11_engine_path_copy == NULL)
2345 return -1;
2346 }
2347 if (pkcs11_module_path != NULL) {
2348 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
04c366cb 2349 if (pkcs11_module_path_copy == NULL) {
bdec7ee5
MS		 2350 os_free(pkcs11_engine_path_copy);
2351 return -1;
2352 }
2353 }
2354
2355 os_free(wpa_s->conf->pkcs11_engine_path);
2356 os_free(wpa_s->conf->pkcs11_module_path);
2357 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2358 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2359
2360 wpa_sm_set_eapol(wpa_s->wpa, NULL);
2361 eapol_sm_deinit(wpa_s->eapol);
2362 wpa_s->eapol = NULL;
2363 if (wpa_supplicant_init_eapol(wpa_s)) {
2364 /* Error -> Reset paths to the default value (NULL) once. */
2365 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
2366 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2367 NULL);
2368
2369 return -1;
2370 }
2371 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2372
2373 return 0;
2374}
2375
2376
86b89452
WS		 2377/**
2378 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
2379 * @wpa_s: wpa_supplicant structure for a network interface
2380 * @ap_scan: AP scan mode
2381 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
2382 *
2383 */
2384int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
2385{
2386
2387 int old_ap_scan;
2388
2389 if (ap_scan < 0 || ap_scan > 2)
2390 return -1;
2391
48f8e036
DS		 2392#ifdef ANDROID
2393 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2394 wpa_s->wpa_state >= WPA_ASSOCIATING &&
2395 wpa_s->wpa_state < WPA_COMPLETED) {
2396 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
2397 "associating", wpa_s->conf->ap_scan, ap_scan);
2398 return 0;
2399 }
2400#endif /* ANDROID */
2401
86b89452
WS		 2402 old_ap_scan = wpa_s->conf->ap_scan;
2403 wpa_s->conf->ap_scan = ap_scan;
2404
2405 if (old_ap_scan != wpa_s->conf->ap_scan)
2406 wpas_notify_ap_scan_changed(wpa_s);
2407
2408 return 0;
2409}
2410
2411
78633c37
SL		 2412/**
2413 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
2414 * @wpa_s: wpa_supplicant structure for a network interface
2415 * @expire_age: Expiration age in seconds
2416 * Returns: 0 if succeed or -1 if expire_age has an invalid value
2417 *
2418 */
2419int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2420 unsigned int bss_expire_age)
2421{
2422 if (bss_expire_age < 10) {
2423 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2424 bss_expire_age);
2425 return -1;
2426 }
2427 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2428 bss_expire_age);
2429 wpa_s->conf->bss_expiration_age = bss_expire_age;
2430
2431 return 0;
2432}
2433
2434
2435/**
2436 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
2437 * @wpa_s: wpa_supplicant structure for a network interface
2438 * @expire_count: number of scans after which an unseen BSS is reclaimed
2439 * Returns: 0 if succeed or -1 if expire_count has an invalid value
2440 *
2441 */
2442int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2443 unsigned int bss_expire_count)
2444{
2445 if (bss_expire_count < 1) {
2446 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2447 bss_expire_count);
2448 return -1;
2449 }
2450 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2451 bss_expire_count);
2452 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2453
2454 return 0;
2455}
2456
2457
c6e86b63
MA		 2458/**
2459 * wpa_supplicant_set_scan_interval - Set scan interval
2460 * @wpa_s: wpa_supplicant structure for a network interface
2461 * @scan_interval: scan interval in seconds
2462 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2463 *
2464 */
2465int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2466 int scan_interval)
2467{
2468 if (scan_interval < 0) {
2469 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2470 scan_interval);
2471 return -1;
2472 }
2473 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2474 scan_interval);
9e737f08 2475 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
c6e86b63
MA		 2476
2477 return 0;
2478}
2479
2480
86b89452
WS		 2481/**
2482 * wpa_supplicant_set_debug_params - Set global debug params
2483 * @global: wpa_global structure
2484 * @debug_level: debug level
2485 * @debug_timestamp: determines if show timestamp in debug data
2486 * @debug_show_keys: determines if show keys in debug data
2487 * Returns: 0 if succeed or -1 if debug_level has wrong value
2488 */
2489int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
2490 int debug_timestamp, int debug_show_keys)
2491{
2492
2493 int old_level, old_timestamp, old_show_keys;
2494
2495 /* check for allowed debuglevels */
14dc0011
PS		 2496 if (debug_level != MSG_EXCESSIVE &&
2497 debug_level != MSG_MSGDUMP &&
86b89452
WS		 2498 debug_level != MSG_DEBUG &&
2499 debug_level != MSG_INFO &&
2500 debug_level != MSG_WARNING &&
2501 debug_level != MSG_ERROR)
2502 return -1;
2503
2504 old_level = wpa_debug_level;
2505 old_timestamp = wpa_debug_timestamp;
2506 old_show_keys = wpa_debug_show_keys;
2507
2508 wpa_debug_level = debug_level;
2509 wpa_debug_timestamp = debug_timestamp ? 1 : 0;
2510 wpa_debug_show_keys = debug_show_keys ? 1 : 0;
2511
db9133ac
WS		 2512 if (wpa_debug_level != old_level)
2513 wpas_notify_debug_level_changed(global);
2514 if (wpa_debug_timestamp != old_timestamp)
2515 wpas_notify_debug_timestamp_changed(global);
2516 if (wpa_debug_show_keys != old_show_keys)
2517 wpas_notify_debug_show_keys_changed(global);
86b89452
WS		 2518
2519 return 0;
2520}
2521
2522
6fc6879b
JM		 2523/**
2524 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2525 * @wpa_s: Pointer to wpa_supplicant data
2526 * Returns: A pointer to the current network structure or %NULL on failure
2527 */
2528struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2529{
2530 struct wpa_ssid *entry;
2531 u8 ssid[MAX_SSID_LEN];
2532 int res;
2533 size_t ssid_len;
2534 u8 bssid[ETH_ALEN];
2535 int wired;
2536
17fbb751
JM		 2537 res = wpa_drv_get_ssid(wpa_s, ssid);
2538 if (res < 0) {
2539 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2540 "driver");
2541 return NULL;
6fc6879b 2542 }
17fbb751 2543 ssid_len = res;
6fc6879b 2544
17fbb751 2545 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
f049052b
BG		 2546 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2547 "driver");
6fc6879b
JM		 2548 return NULL;
2549 }
2550
c2a04078
JM		 2551 wired = wpa_s->conf->ap_scan == 0 &&
2552 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
6fc6879b
JM		 2553
2554 entry = wpa_s->conf->ssid;
2555 while (entry) {
349493bd 2556 if (!wpas_network_disabled(wpa_s, entry) &&
6fc6879b
JM		 2557 ((ssid_len == entry->ssid_len &&
2558 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
2559 (!entry->bssid_set ||
2560 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2561 return entry;
24c23d1b 2562#ifdef CONFIG_WPS
349493bd 2563 if (!wpas_network_disabled(wpa_s, entry) &&
24c23d1b
JM		 2564 (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
2565 (entry->ssid == NULL || entry->ssid_len == 0) &&
2566 (!entry->bssid_set ||
2567 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2568 return entry;
2569#endif /* CONFIG_WPS */
7d232e23 2570
349493bd 2571 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
7d232e23
ZC		 2572 entry->ssid_len == 0 &&
2573 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
2574 return entry;
2575
6fc6879b
JM		 2576 entry = entry->next;
2577 }
2578
2579 return NULL;
2580}
2581
2582
7756114f
JM		 2583static int select_driver(struct wpa_supplicant *wpa_s, int i)
2584{
2585 struct wpa_global *global = wpa_s->global;
2586
2587 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
2588 global->drv_priv[i] = wpa_drivers[i]->global_init();
2589 if (global->drv_priv[i] == NULL) {
2590 wpa_printf(MSG_ERROR, "Failed to initialize driver "
2591 "'%s'", wpa_drivers[i]->name);
2592 return -1;
2593 }
2594 }
2595
2596 wpa_s->driver = wpa_drivers[i];
2597 wpa_s->global_drv_priv = global->drv_priv[i];
2598
2599 return 0;
2600}
2601
2602
6fc6879b
JM		 2603static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2604 const char *name)
2605{
2606 int i;
362f781e 2607 size_t len;
74b1c84a 2608 const char *pos, *driver = name;
6fc6879b
JM		 2609
2610 if (wpa_s == NULL)
2611 return -1;
2612
c5121837 2613 if (wpa_drivers[0] == NULL) {
f049052b
BG		 2614 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2615 "wpa_supplicant");
6fc6879b
JM		 2616 return -1;
2617 }
2618
2619 if (name == NULL) {
2620 /* default to first driver in the list */
7756114f 2621 return select_driver(wpa_s, 0);
6fc6879b
JM		 2622 }
2623
74b1c84a
SO		 2624 do {
2625 pos = os_strchr(driver, ',');
2626 if (pos)
2627 len = pos - driver;
2628 else
2629 len = os_strlen(driver);
2630
2631 for (i = 0; wpa_drivers[i]; i++) {
2632 if (os_strlen(wpa_drivers[i]->name) == len &&
2633 os_strncmp(driver, wpa_drivers[i]->name, len) ==
0f4668ce
DW		 2634 0) {
2635 /* First driver that succeeds wins */
2636 if (select_driver(wpa_s, i) == 0)
2637 return 0;
2638 }
6fc6879b 2639 }
74b1c84a
SO		 2640
2641 driver = pos + 1;
2642 } while (pos);
6fc6879b 2643
f049052b 2644 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
6fc6879b
JM		 2645 return -1;
2646}
2647
2648
a8e0505b
JM		 2649/**
2650 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2651 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2652 * with struct wpa_driver_ops::init()
2653 * @src_addr: Source address of the EAPOL frame
2654 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2655 * @len: Length of the EAPOL data
2656 *
2657 * This function is called for each received EAPOL frame. Most driver
2658 * interfaces rely on more generic OS mechanism for receiving frames through
2659 * l2_packet, but if such a mechanism is not available, the driver wrapper may
2660 * take care of received EAPOL frames and deliver them to the core supplicant
2661 * code by calling this function.
2662 */
6fc6879b
JM		 2663void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
2664 const u8 *buf, size_t len)
2665{
2666 struct wpa_supplicant *wpa_s = ctx;
2667
f049052b 2668 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
6fc6879b
JM		 2669 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
2670
db76aa64
JM		 2671#ifdef CONFIG_PEERKEY
2672 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
2673 wpa_s->current_ssid->peerkey &&
2674 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2675 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
2676 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
2677 return;
2678 }
2679#endif /* CONFIG_PEERKEY */
2680
3ab35a66
JM		 2681 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2682 (wpa_s->last_eapol_matches_bssid &&
2683#ifdef CONFIG_AP
2684 !wpa_s->ap_iface &&
2685#endif /* CONFIG_AP */
2686 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
1ff73338
JM		 2687 /*
2688 * There is possible race condition between receiving the
2689 * association event and the EAPOL frame since they are coming
2690 * through different paths from the driver. In order to avoid
2691 * issues in trying to process the EAPOL frame before receiving
2692 * association information, lets queue it for processing until
3ab35a66
JM		 2693 * the association event is received. This may also be needed in
2694 * driver-based roaming case, so also use src_addr != BSSID as a
2695 * trigger if we have previously confirmed that the
2696 * Authenticator uses BSSID as the src_addr (which is not the
2697 * case with wired IEEE 802.1X).
1ff73338 2698 */
f049052b 2699 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3ab35a66
JM		 2700 "of received EAPOL frame (state=%s bssid=" MACSTR ")",
2701 wpa_supplicant_state_txt(wpa_s->wpa_state),
2702 MAC2STR(wpa_s->bssid));
1ff73338
JM		 2703 wpabuf_free(wpa_s->pending_eapol_rx);
2704 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2705 if (wpa_s->pending_eapol_rx) {
c2be937c 2706 os_get_reltime(&wpa_s->pending_eapol_rx_time);
1ff73338
JM		 2707 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2708 ETH_ALEN);
2709 }
2710 return;
2711 }
2712
3ab35a66
JM		 2713 wpa_s->last_eapol_matches_bssid =
2714 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2715
db149ac9
JM		 2716#ifdef CONFIG_AP
2717 if (wpa_s->ap_iface) {
2718 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2719 return;
2720 }
2721#endif /* CONFIG_AP */
2722
6fc6879b 2723 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
f049052b
BG		 2724 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2725 "no key management is configured");
6fc6879b
JM		 2726 return;
2727 }
2728
2729 if (wpa_s->eapol_received == 0 &&
c2a04078 2730 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
56586197 2731 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
9c972abb
JM		 2732 wpa_s->wpa_state != WPA_COMPLETED) &&
2733 (wpa_s->current_ssid == NULL ||
2734 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
6fc6879b
JM		 2735 /* Timeout for completing IEEE 802.1X and WPA authentication */
2736 wpa_supplicant_req_auth_timeout(
2737 wpa_s,
56586197 2738 (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
a6f06dab
AT		 2739 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2740 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
6fc6879b
JM		 2741 70 : 10, 0);
2742 }
2743 wpa_s->eapol_received++;
2744
2745 if (wpa_s->countermeasures) {
f049052b
BG		 2746 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2747 "EAPOL packet");
6fc6879b
JM		 2748 return;
2749 }
2750
8be18440
JM		 2751#ifdef CONFIG_IBSS_RSN
2752 if (wpa_s->current_ssid &&
d7dcba70 2753 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
8be18440
JM		 2754 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2755 return;
2756 }
2757#endif /* CONFIG_IBSS_RSN */
2758
6fc6879b
JM		 2759 /* Source address of the incoming EAPOL frame could be compared to the
2760 * current BSSID. However, it is possible that a centralized
2761 * Authenticator could be using another MAC address than the BSSID of
2762 * an AP, so just allow any address to be used for now. The replies are
2763 * still sent to the current BSSID (if available), though. */
2764
2765 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
56586197 2766 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
6fc6879b
JM		 2767 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2768 return;
2769 wpa_drv_poll(wpa_s);
c2a04078 2770 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
6fc6879b 2771 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
56586197 2772 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
6fc6879b
JM		 2773 /*
2774 * Set portValid = TRUE here since we are going to skip 4-way
2775 * handshake processing which would normally set portValid. We
2776 * need this to allow the EAPOL state machines to be completed
2777 * without going through EAPOL-Key handshake.
2778 */
2779 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2780 }
2781}
2782
2783
bfba8deb 2784int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
6fc6879b 2785{
6fc6879b
JM		 2786 if (wpa_s->driver->send_eapol) {
2787 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2788 if (addr)
2789 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
1c42b42f
JM		 2790 } else if ((!wpa_s->p2p_mgmt ||
2791 !(wpa_s->drv_flags &
2792 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
c68f6200 2793 !(wpa_s->drv_flags &
fdadd5fe 2794 WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
bfba8deb 2795 l2_packet_deinit(wpa_s->l2);
6fc6879b
JM		 2796 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2797 wpa_drv_get_mac_addr(wpa_s),
2798 ETH_P_EAPOL,
2799 wpa_supplicant_rx_eapol, wpa_s, 0);
2800 if (wpa_s->l2 == NULL)
2801 return -1;
fdadd5fe
JM		 2802 } else {
2803 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2804 if (addr)
2805 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
6fc6879b
JM		 2806 }
2807
2808 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
f049052b 2809 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
6fc6879b
JM		 2810 return -1;
2811 }
2812
c267753b
JM		 2813 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2814
bfba8deb
JM		 2815 return 0;
2816}
2817
2818
25f839c6
JM		 2819static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
2820 const u8 *buf, size_t len)
2821{
2822 struct wpa_supplicant *wpa_s = ctx;
2823 const struct l2_ethhdr *eth;
2824
2825 if (len < sizeof(*eth))
2826 return;
2827 eth = (const struct l2_ethhdr *) buf;
2828
2829 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2830 !(eth->h_dest[0] & 0x01)) {
2831 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2832 " (bridge - not for this interface - ignore)",
2833 MAC2STR(src_addr), MAC2STR(eth->h_dest));
2834 return;
2835 }
2836
2837 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2838 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
2839 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2840 len - sizeof(*eth));
2841}
2842
2843
bfba8deb
JM		 2844/**
2845 * wpa_supplicant_driver_init - Initialize driver interface parameters
2846 * @wpa_s: Pointer to wpa_supplicant data
2847 * Returns: 0 on success, -1 on failure
2848 *
2849 * This function is called to initialize driver interface parameters.
2850 * wpa_drv_init() must have been called before this function to initialize the
2851 * driver interface.
2852 */
2853int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2854{
2855 static int interface_count = 0;
2856
2857 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2858 return -1;
2859
c68f6200
AS		 2860 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2861 MAC2STR(wpa_s->own_addr));
a313d17d 2862 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
c68f6200
AS		 2863 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2864
6fc6879b 2865 if (wpa_s->bridge_ifname[0]) {
f049052b
BG		 2866 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2867 "interface '%s'", wpa_s->bridge_ifname);
6fc6879b
JM		 2868 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2869 wpa_s->own_addr,
2870 ETH_P_EAPOL,
25f839c6
JM		 2871 wpa_supplicant_rx_eapol_bridge,
2872 wpa_s, 1);
6fc6879b 2873 if (wpa_s->l2_br == NULL) {
f049052b
BG		 2874 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2875 "connection for the bridge interface '%s'",
2876 wpa_s->bridge_ifname);
6fc6879b
JM		 2877 return -1;
2878 }
2879 }
2880
6fc6879b
JM		 2881 wpa_clear_keys(wpa_s, NULL);
2882
2883 /* Make sure that TKIP countermeasures are not left enabled (could
2884 * happen if wpa_supplicant is killed during countermeasures. */
2885 wpa_drv_set_countermeasures(wpa_s, 0);
2886
f049052b 2887 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
6fc6879b
JM		 2888 wpa_drv_flush_pmkid(wpa_s);
2889
ba2a573c 2890 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
b3aa456b
ES		 2891 wpa_s->prev_scan_wildcard = 0;
2892
349493bd 2893 if (wpa_supplicant_enabled_networks(wpa_s)) {
a0e9d892
AS		 2894 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
2895 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2896 interface_count = 0;
2897 }
3a94adbf 2898 if (!wpa_s->p2p_mgmt &&
5d0d72a3
BG		 2899 wpa_supplicant_delayed_sched_scan(wpa_s,
2900 interface_count % 3,
6a90053c 2901 100000))
5d0d72a3 2902 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
a4cba8f1 2903 100000);
74e259ec
JM		 2904 interface_count++;
2905 } else
2906 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
6fc6879b
JM		 2907
2908 return 0;
2909}
2910
2911
2912static int wpa_supplicant_daemon(const char *pid_file)
2913{
2914 wpa_printf(MSG_DEBUG, "Daemonize..");
2915 return os_daemonize(pid_file);
2916}
2917
2918
2919static struct wpa_supplicant * wpa_supplicant_alloc(void)
2920{
2921 struct wpa_supplicant *wpa_s;
2922
2923 wpa_s = os_zalloc(sizeof(*wpa_s));
2924 if (wpa_s == NULL)
2925 return NULL;
4115303b 2926 wpa_s->scan_req = INITIAL_SCAN_REQ;
67b9bd08 2927 wpa_s->scan_interval = 5;
c302f207 2928 wpa_s->new_connection = 1;
b22128ef 2929 wpa_s->parent = wpa_s;
cbdf3507 2930 wpa_s->sched_scanning = 0;
6fc6879b
JM		 2931
2932 return wpa_s;
2933}
2934
2935
80e8a5ee
BG		 2936#ifdef CONFIG_HT_OVERRIDES
2937
2938static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2939 struct ieee80211_ht_capabilities *htcaps,
2940 struct ieee80211_ht_capabilities *htcaps_mask,
2941 const char *ht_mcs)
2942{
2943 /* parse ht_mcs into hex array */
2944 int i;
2945 const char *tmp = ht_mcs;
2946 char *end = NULL;
2947
2948 /* If ht_mcs is null, do not set anything */
2949 if (!ht_mcs)
2950 return 0;
2951
2952 /* This is what we are setting in the kernel */
2953 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
2954
2955 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2956
2957 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2958 errno = 0;
2959 long v = strtol(tmp, &end, 16);
2960 if (errno == 0) {
2961 wpa_msg(wpa_s, MSG_DEBUG,
2962 "htcap value[%i]: %ld end: %p tmp: %p",
2963 i, v, end, tmp);
2964 if (end == tmp)
2965 break;
2966
2967 htcaps->supported_mcs_set[i] = v;
2968 tmp = end;
2969 } else {
2970 wpa_msg(wpa_s, MSG_ERROR,
2971 "Failed to parse ht-mcs: %s, error: %s\n",
2972 ht_mcs, strerror(errno));
2973 return -1;
2974 }
2975 }
2976
2977 /*
2978 * If we were able to parse any values, then set mask for the MCS set.
2979 */
2980 if (i) {
2981 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
2982 IEEE80211_HT_MCS_MASK_LEN - 1);
2983 /* skip the 3 reserved bits */
2984 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
2985 0x1f;
2986 }
2987
2988 return 0;
2989}
2990
2991
2992static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2993 struct ieee80211_ht_capabilities *htcaps,
2994 struct ieee80211_ht_capabilities *htcaps_mask,
2995 int disabled)
2996{
5bc28571 2997 le16 msk;
80e8a5ee
BG		 2998
2999 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
3000
3001 if (disabled == -1)
3002 return 0;
3003
3004 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3005 htcaps_mask->ht_capabilities_info |= msk;
3006 if (disabled)
3007 htcaps->ht_capabilities_info &= msk;
3008 else
3009 htcaps->ht_capabilities_info |= msk;
3010
3011 return 0;
3012}
3013
3014
3015static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
3016 struct ieee80211_ht_capabilities *htcaps,
3017 struct ieee80211_ht_capabilities *htcaps_mask,
3018 int factor)
3019{
3020 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
3021
3022 if (factor == -1)
3023 return 0;
3024
3025 if (factor < 0 || factor > 3) {
3026 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
3027 "Must be 0-3 or -1", factor);
3028 return -EINVAL;
3029 }
3030
3031 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
3032 htcaps->a_mpdu_params &= ~0x3;
3033 htcaps->a_mpdu_params |= factor & 0x3;
3034
3035 return 0;
3036}
3037
3038
3039static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3040 struct ieee80211_ht_capabilities *htcaps,
3041 struct ieee80211_ht_capabilities *htcaps_mask,
3042 int density)
3043{
3044 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3045
3046 if (density == -1)
3047 return 0;
3048
3049 if (density < 0 || density > 7) {
3050 wpa_msg(wpa_s, MSG_ERROR,
3051 "ampdu_density: %d out of range. Must be 0-7 or -1.",
3052 density);
3053 return -EINVAL;
3054 }
3055
3056 htcaps_mask->a_mpdu_params |= 0x1C;
3057 htcaps->a_mpdu_params &= ~(0x1C);
3058 htcaps->a_mpdu_params |= (density << 2) & 0x1C;
3059
3060 return 0;
3061}
3062
3063
3064static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3065 struct ieee80211_ht_capabilities *htcaps,
3066 struct ieee80211_ht_capabilities *htcaps_mask,
3067 int disabled)
3068{
3069 /* Masking these out disables HT40 */
5bc28571
JM		 3070 le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
3071 HT_CAP_INFO_SHORT_GI40MHZ);
80e8a5ee
BG		 3072
3073 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3074
3075 if (disabled)
3076 htcaps->ht_capabilities_info &= ~msk;
3077 else
3078 htcaps->ht_capabilities_info |= msk;
3079
3080 htcaps_mask->ht_capabilities_info |= msk;
3081
3082 return 0;
3083}
3084
3085
a90497f8
BG		 3086static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3087 struct ieee80211_ht_capabilities *htcaps,
3088 struct ieee80211_ht_capabilities *htcaps_mask,
3089 int disabled)
3090{
3091 /* Masking these out disables SGI */
5bc28571
JM		 3092 le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
3093 HT_CAP_INFO_SHORT_GI40MHZ);
a90497f8
BG		 3094
3095 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3096
3097 if (disabled)
3098 htcaps->ht_capabilities_info &= ~msk;
3099 else
3100 htcaps->ht_capabilities_info |= msk;
3101
3102 htcaps_mask->ht_capabilities_info |= msk;
3103
3104 return 0;
3105}
3106
3107
39a5800f
PK		 3108static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3109 struct ieee80211_ht_capabilities *htcaps,
3110 struct ieee80211_ht_capabilities *htcaps_mask,
3111 int disabled)
3112{
3113 /* Masking these out disables LDPC */
5bc28571 3114 le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
39a5800f
PK		 3115
3116 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3117
3118 if (disabled)
3119 htcaps->ht_capabilities_info &= ~msk;
3120 else
3121 htcaps->ht_capabilities_info |= msk;
3122
3123 htcaps_mask->ht_capabilities_info |= msk;
3124
3125 return 0;
3126}
3127
3128
80e8a5ee
BG		 3129void wpa_supplicant_apply_ht_overrides(
3130 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3131 struct wpa_driver_associate_params *params)
3132{
3133 struct ieee80211_ht_capabilities *htcaps;
3134 struct ieee80211_ht_capabilities *htcaps_mask;
3135
3136 if (!ssid)
3137 return;
3138
3139 params->disable_ht = ssid->disable_ht;
3140 if (!params->htcaps || !params->htcaps_mask)
3141 return;
3142
3143 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
3144 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
3145 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3146 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3147 ssid->disable_max_amsdu);
3148 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3149 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3150 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
a90497f8 3151 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
39a5800f 3152 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
d41cc8cc
JM		 3153
3154 if (ssid->ht40_intolerant) {
5bc28571 3155 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
d41cc8cc
JM		 3156 htcaps->ht_capabilities_info |= bit;
3157 htcaps_mask->ht_capabilities_info |= bit;
3158 }
80e8a5ee
BG		 3159}
3160
3161#endif /* CONFIG_HT_OVERRIDES */
3162
3163
e9ee8dc3
JB		 3164#ifdef CONFIG_VHT_OVERRIDES
3165void wpa_supplicant_apply_vht_overrides(
3166 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3167 struct wpa_driver_associate_params *params)
3168{
3169 struct ieee80211_vht_capabilities *vhtcaps;
3170 struct ieee80211_vht_capabilities *vhtcaps_mask;
4f560cde
EP		 3171#ifdef CONFIG_HT_OVERRIDES
3172 int max_ampdu;
3173 const u32 max_ampdu_mask = VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX;
3174#endif /* CONFIG_HT_OVERRIDES */
e9ee8dc3
JB		 3175
3176 if (!ssid)
3177 return;
3178
3179 params->disable_vht = ssid->disable_vht;
3180
3181 vhtcaps = (void *) params->vhtcaps;
3182 vhtcaps_mask = (void *) params->vhtcaps_mask;
3183
3184 if (!vhtcaps || !vhtcaps_mask)
3185 return;
3186
3187 vhtcaps->vht_capabilities_info = ssid->vht_capa;
3188 vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask;
3189
4f560cde
EP		 3190#ifdef CONFIG_HT_OVERRIDES
3191 /* if max ampdu is <= 3, we have to make the HT cap the same */
3192 if (ssid->vht_capa_mask & max_ampdu_mask) {
3193 max_ampdu = (ssid->vht_capa & max_ampdu_mask) >>
3194 find_first_bit(max_ampdu_mask);
3195
3196 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
3197 wpa_set_ampdu_factor(wpa_s,
3198 (void *) params->htcaps,
3199 (void *) params->htcaps_mask,
3200 max_ampdu);
3201 }
3202#endif /* CONFIG_HT_OVERRIDES */
3203
e9ee8dc3
JB		 3204#define OVERRIDE_MCS(i) \
3205 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
3206 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
3207 3 << 2 * (i - 1); \
3208 vhtcaps->vht_supported_mcs_set.tx_map |= \
3209 ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1); \
3210 } \
3211 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
3212 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
3213 3 << 2 * (i - 1); \
3214 vhtcaps->vht_supported_mcs_set.rx_map |= \
3215 ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1); \
3216 }
3217
3218 OVERRIDE_MCS(1);
3219 OVERRIDE_MCS(2);
3220 OVERRIDE_MCS(3);
3221 OVERRIDE_MCS(4);
3222 OVERRIDE_MCS(5);
3223 OVERRIDE_MCS(6);
3224 OVERRIDE_MCS(7);
3225 OVERRIDE_MCS(8);
3226}
3227#endif /* CONFIG_VHT_OVERRIDES */
3228
3229
f64adcd7
JM		 3230static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3231{
3232#ifdef PCSC_FUNCS
3233 size_t len;
3234
3235 if (!wpa_s->conf->pcsc_reader)
3236 return 0;
3237
22cf7d73 3238 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
f64adcd7
JM		 3239 if (!wpa_s->scard)
3240 return 1;
3241
3242 if (wpa_s->conf->pcsc_pin &&
3243 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3244 scard_deinit(wpa_s->scard);
3245 wpa_s->scard = NULL;
3246 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3247 return -1;
3248 }
3249
3250 len = sizeof(wpa_s->imsi) - 1;
3251 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3252 scard_deinit(wpa_s->scard);
3253 wpa_s->scard = NULL;
3254 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3255 return -1;
3256 }
3257 wpa_s->imsi[len] = '\0';
3258
3259 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3260
3261 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3262 wpa_s->imsi, wpa_s->mnc_len);
3263
3264 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3265 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3266#endif /* PCSC_FUNCS */
3267
3268 return 0;
3269}
3270
3271
306ae225
JM		 3272int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3273{
3274 char *val, *pos;
3275
3276 ext_password_deinit(wpa_s->ext_pw);
3277 wpa_s->ext_pw = NULL;
3278 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3279
3280 if (!wpa_s->conf->ext_password_backend)
3281 return 0;
3282
3283 val = os_strdup(wpa_s->conf->ext_password_backend);
3284 if (val == NULL)
3285 return -1;
3286 pos = os_strchr(val, ':');
3287 if (pos)
3288 *pos++ = '\0';
3289
3290 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
3291
3292 wpa_s->ext_pw = ext_password_init(val, pos);
3293 os_free(val);
3294 if (wpa_s->ext_pw == NULL) {
3295 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
3296 return -1;
3297 }
3298 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3299
3300 return 0;
3301}
3302
3303
a520bf4a 3304static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
6cbdb0c5 3305 const struct wpa_driver_capa *capa)
e4fa8b12 3306{
88cb27c7
DS		 3307 struct wowlan_triggers *triggers;
3308 int ret = 0;
e4fa8b12
EP		 3309
3310 if (!wpa_s->conf->wowlan_triggers)
3311 return 0;
3312
88cb27c7
DS		 3313 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
3314 if (triggers) {
3315 ret = wpa_drv_wowlan(wpa_s, triggers);
3316 os_free(triggers);
e4fa8b12 3317 }
e4fa8b12
EP		 3318 return ret;
3319}
3320
3321
202dec2a
JM		 3322static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
3323 const char *rn)
3324{
3325 struct wpa_supplicant *iface = wpa_s->global->ifaces;
3326 struct wpa_radio *radio;
3327
3328 while (rn && iface) {
3329 radio = iface->radio;
3330 if (radio && os_strcmp(rn, radio->name) == 0) {
3331 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
3332 wpa_s->ifname, rn);
3333 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3334 return radio;
3335 }
b154a24e
TB		 3336
3337 iface = iface->next;
202dec2a
JM		 3338 }
3339
3340 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
3341 wpa_s->ifname, rn ? rn : "N/A");
3342 radio = os_zalloc(sizeof(*radio));
3343 if (radio == NULL)
3344 return NULL;
3345
3346 if (rn)
3347 os_strlcpy(radio->name, rn, sizeof(radio->name));
3348 dl_list_init(&radio->ifaces);
b1ae396f 3349 dl_list_init(&radio->work);
202dec2a
JM		 3350 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3351
3352 return radio;
3353}
3354
3355
b1ae396f
JM		 3356static void radio_work_free(struct wpa_radio_work *work)
3357{
d12a51b5
JM		 3358 if (work->wpa_s->scan_work == work) {
3359 /* This should not really happen. */
3360 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
3361 work->type, work, work->started);
3362 work->wpa_s->scan_work = NULL;
3363 }
3364
1b5d4714
JM		 3365#ifdef CONFIG_P2P
3366 if (work->wpa_s->p2p_scan_work == work) {
3367 /* This should not really happen. */
3368 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
3369 work->type, work, work->started);
3370 work->wpa_s->p2p_scan_work = NULL;
3371 }
3372#endif /* CONFIG_P2P */
3373
b1ae396f
JM		 3374 dl_list_del(&work->list);
3375 os_free(work);
3376}
3377
3378
3379static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
3380{
3381 struct wpa_radio *radio = eloop_ctx;
3382 struct wpa_radio_work *work;
3383 struct os_reltime now, diff;
6428d0a7 3384 struct wpa_supplicant *wpa_s;
b1ae396f
JM		 3385
3386 work = dl_list_first(&radio->work, struct wpa_radio_work, list);
3387 if (work == NULL)
3388 return;
3389
3390 if (work->started)
3391 return; /* already started and still in progress */
3392
6428d0a7
JM		 3393 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
3394 radio_list);
3395 if (wpa_s && wpa_s->external_scan_running) {
3396 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
3397 return;
3398 }
3399
b1ae396f
JM		 3400 os_get_reltime(&now);
3401 os_reltime_sub(&now, &work->time, &diff);
3402 wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting radio work '%s'@%p after %ld.%06ld second wait",
3403 work->type, work, diff.sec, diff.usec);
3404 work->started = 1;
3405 work->time = now;
3406 work->cb(work, 0);
3407}
3408
3409
b3253ebb
AO		 3410/*
3411 * This function removes both started and pending radio works running on
3412 * the provided interface's radio.
3413 * Prior to the removal of the radio work, its callback (cb) is called with
3414 * deinit set to be 1. Each work's callback is responsible for clearing its
3415 * internal data and restoring to a correct state.
3416 * @wpa_s: wpa_supplicant data
3417 * @type: type of works to be removed
3418 * @remove_all: 1 to remove all the works on this radio, 0 to remove only
3419 * this interface's works.
3420 */
3421void radio_remove_works(struct wpa_supplicant *wpa_s,
3422 const char *type, int remove_all)
b1ae396f
JM		 3423{
3424 struct wpa_radio_work *work, *tmp;
3425 struct wpa_radio *radio = wpa_s->radio;
3426
3427 dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
3428 list) {
b3253ebb 3429 if (type && os_strcmp(type, work->type) != 0)
b1ae396f 3430 continue;
b3253ebb
AO		 3431
3432 /* skip other ifaces' works */
3433 if (!remove_all && work->wpa_s != wpa_s)
b1ae396f 3434 continue;
b3253ebb
AO		 3435
3436 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
3437 work->type, work, work->started ? " (started)" : "");
b1ae396f
JM		 3438 work->cb(work, 1);
3439 radio_work_free(work);
3440 }
b3253ebb
AO		 3441
3442 /* in case we removed the started work */
3443 radio_work_check_next(wpa_s);
b1ae396f
JM		 3444}
3445
3446
202dec2a
JM		 3447static void radio_remove_interface(struct wpa_supplicant *wpa_s)
3448{
3449 struct wpa_radio *radio = wpa_s->radio;
3450
3451 if (!radio)
3452 return;
3453
3454 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
3455 wpa_s->ifname, radio->name);
3456 dl_list_del(&wpa_s->radio_list);
c46235aa
AO		 3457 radio_remove_works(wpa_s, NULL, 0);
3458 wpa_s->radio = NULL;
3459 if (!dl_list_empty(&radio->ifaces))
202dec2a
JM		 3460 return; /* Interfaces remain for this radio */
3461
3462 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
b1ae396f 3463 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
202dec2a
JM		 3464 os_free(radio);
3465}
3466
3467
6428d0a7 3468void radio_work_check_next(struct wpa_supplicant *wpa_s)
b1ae396f
JM		 3469{
3470 struct wpa_radio *radio = wpa_s->radio;
3471
3472 if (dl_list_empty(&radio->work))
3473 return;
3474 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
3475 eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
3476}
3477
3478
3479/**
3480 * radio_add_work - Add a radio work item
3481 * @wpa_s: Pointer to wpa_supplicant data
3482 * @freq: Frequency of the offchannel operation in MHz or 0
3483 * @type: Unique identifier for each type of work
3484 * @next: Force as the next work to be executed
3485 * @cb: Callback function for indicating when radio is available
3486 * @ctx: Context pointer for the work (work->ctx in cb())
3487 * Returns: 0 on success, -1 on failure
3488 *
3489 * This function is used to request time for an operation that requires
3490 * exclusive radio control. Once the radio is available, the registered callback
3491 * function will be called. radio_work_done() must be called once the exclusive
3492 * radio operation has been completed, so that the radio is freed for other
3493 * operations. The special case of deinit=1 is used to free the context data
3494 * during interface removal. That does not allow the callback function to start
3495 * the radio operation, i.e., it must free any resources allocated for the radio
3496 * work and return.
3497 *
3498 * The @freq parameter can be used to indicate a single channel on which the
3499 * offchannel operation will occur. This may allow multiple radio work
3500 * operations to be performed in parallel if they apply for the same channel.
3501 * Setting this to 0 indicates that the work item may use multiple channels or
3502 * requires exclusive control of the radio.
3503 */
3504int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
3505 const char *type, int next,
3506 void (*cb)(struct wpa_radio_work *work, int deinit),
3507 void *ctx)
3508{
3509 struct wpa_radio_work *work;
3510 int was_empty;
3511
3512 work = os_zalloc(sizeof(*work));
3513 if (work == NULL)
3514 return -1;
3515 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
3516 os_get_reltime(&work->time);
3517 work->freq = freq;
3518 work->type = type;
3519 work->wpa_s = wpa_s;
3520 work->cb = cb;
3521 work->ctx = ctx;
3522
3523 was_empty = dl_list_empty(&wpa_s->radio->work);
3524 if (next)
3525 dl_list_add(&wpa_s->radio->work, &work->list);
3526 else
3527 dl_list_add_tail(&wpa_s->radio->work, &work->list);
3528 if (was_empty) {
3529 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
3530 radio_work_check_next(wpa_s);
3531 }
3532
3533 return 0;
3534}
3535
3536
3537/**
3538 * radio_work_done - Indicate that a radio work item has been completed
3539 * @work: Completed work
3540 *
3541 * This function is called once the callback function registered with
3542 * radio_add_work() has completed its work.
3543 */
3544void radio_work_done(struct wpa_radio_work *work)
3545{
3546 struct wpa_supplicant *wpa_s = work->wpa_s;
3547 struct os_reltime now, diff;
1f965e62 3548 unsigned int started = work->started;
b1ae396f
JM		 3549
3550 os_get_reltime(&now);
3551 os_reltime_sub(&now, &work->time, &diff);
1f965e62
JM		 3552 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
3553 work->type, work, started ? "done" : "canceled",
3554 diff.sec, diff.usec);
b1ae396f 3555 radio_work_free(work);
1f965e62
JM		 3556 if (started)
3557 radio_work_check_next(wpa_s);
b1ae396f
JM		 3558}
3559
3560
a7f5271d
JM		 3561struct wpa_radio_work *
3562radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
f0e30c84
JM		 3563{
3564 struct wpa_radio_work *work;
3565 struct wpa_radio *radio = wpa_s->radio;
3566
3567 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
3568 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
a7f5271d 3569 return work;
f0e30c84
JM		 3570 }
3571
a7f5271d 3572 return NULL;
f0e30c84
JM		 3573}
3574
3575
73c00fd7
JM		 3576static int wpas_init_driver(struct wpa_supplicant *wpa_s,
3577 struct wpa_interface *iface)
3578{
202dec2a 3579 const char *ifname, *driver, *rn;
73c00fd7
JM		 3580
3581 driver = iface->driver;
3582next_driver:
3583 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
3584 return -1;
3585
3586 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
3587 if (wpa_s->drv_priv == NULL) {
3588 const char *pos;
3589 pos = driver ? os_strchr(driver, ',') : NULL;
3590 if (pos) {
3591 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
3592 "driver interface - try next driver wrapper");
3593 driver = pos + 1;
3594 goto next_driver;
3595 }
3596 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
3597 "interface");
3598 return -1;
3599 }
3600 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
3601 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
3602 "driver_param '%s'", wpa_s->conf->driver_param);
3603 return -1;
3604 }
3605
3606 ifname = wpa_drv_get_ifname(wpa_s);
3607 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
3608 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
3609 "interface name with '%s'", ifname);
3610 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
3611 }
3612
95bf699f 3613 rn = wpa_driver_get_radio_name(wpa_s);
202dec2a
JM		 3614 if (rn && rn[0] == '\0')
3615 rn = NULL;
3616
3617 wpa_s->radio = radio_add_interface(wpa_s, rn);
3618 if (wpa_s->radio == NULL)
3619 return -1;
3620
73c00fd7
JM		 3621 return 0;
3622}
3623
3624
6fc6879b
JM		 3625static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
3626 struct wpa_interface *iface)
3627{
362f781e 3628 struct wpa_driver_capa capa;
6cbdb0c5 3629 int capa_res;
362f781e 3630
6fc6879b
JM		 3631 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
3632 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
3633 iface->confname ? iface->confname : "N/A",
3634 iface->driver ? iface->driver : "default",
3635 iface->ctrl_interface ? iface->ctrl_interface : "N/A",
3636 iface->bridge_ifname ? iface->bridge_ifname : "N/A");
3637
6fc6879b
JM		 3638 if (iface->confname) {
3639#ifdef CONFIG_BACKEND_FILE
3640 wpa_s->confname = os_rel2abs_path(iface->confname);
3641 if (wpa_s->confname == NULL) {
3642 wpa_printf(MSG_ERROR, "Failed to get absolute path "
3643 "for configuration file '%s'.",
3644 iface->confname);
3645 return -1;
3646 }
3647 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
3648 iface->confname, wpa_s->confname);
3649#else /* CONFIG_BACKEND_FILE */
3650 wpa_s->confname = os_strdup(iface->confname);
3651#endif /* CONFIG_BACKEND_FILE */
e6304cad 3652 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
6fc6879b
JM		 3653 if (wpa_s->conf == NULL) {
3654 wpa_printf(MSG_ERROR, "Failed to read or parse "
3655 "configuration '%s'.", wpa_s->confname);
3656 return -1;
3657 }
e6304cad
DS		 3658 wpa_s->confanother = os_rel2abs_path(iface->confanother);
3659 wpa_config_read(wpa_s->confanother, wpa_s->conf);
6fc6879b
JM		 3660
3661 /*
3662 * Override ctrl_interface and driver_param if set on command
3663 * line.
3664 */
3665 if (iface->ctrl_interface) {
3666 os_free(wpa_s->conf->ctrl_interface);
3667 wpa_s->conf->ctrl_interface =
3668 os_strdup(iface->ctrl_interface);
3669 }
3670
3671 if (iface->driver_param) {
3672 os_free(wpa_s->conf->driver_param);
3673 wpa_s->conf->driver_param =
3674 os_strdup(iface->driver_param);
3675 }
78f79fe5
JM		 3676
3677 if (iface->p2p_mgmt && !iface->ctrl_interface) {
3678 os_free(wpa_s->conf->ctrl_interface);
3679 wpa_s->conf->ctrl_interface = NULL;
3680 }
6fc6879b
JM		 3681 } else
3682 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
3683 iface->driver_param);
3684
3685 if (wpa_s->conf == NULL) {
3686 wpa_printf(MSG_ERROR, "\nNo configuration found.");
3687 return -1;
3688 }
3689
3690 if (iface->ifname == NULL) {
3691 wpa_printf(MSG_ERROR, "\nInterface name is required.");
3692 return -1;
3693 }
3694 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
3695 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
3696 iface->ifname);
3697 return -1;
3698 }
3699 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
3700
3701 if (iface->bridge_ifname) {
3702 if (os_strlen(iface->bridge_ifname) >=
3703 sizeof(wpa_s->bridge_ifname)) {
3704 wpa_printf(MSG_ERROR, "\nToo long bridge interface "
3705 "name '%s'.", iface->bridge_ifname);
3706 return -1;
3707 }
3708 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
3709 sizeof(wpa_s->bridge_ifname));
3710 }
3711
6fc6879b
JM		 3712 /* RSNA Supplicant Key Management - INITIALIZE */
3713 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
3714 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
3715
3716 /* Initialize driver interface and register driver event handler before
3717 * L2 receive handler so that association events are processed before
3718 * EAPOL-Key packets if both become available for the same select()
3719 * call. */
73c00fd7 3720 if (wpas_init_driver(wpa_s, iface) < 0)
362f781e
JM		 3721 return -1;
3722
6fc6879b
JM		 3723 if (wpa_supplicant_init_wpa(wpa_s) < 0)
3724 return -1;
3725
3726 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
3727 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
3728 NULL);
3729 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
3730
3731 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
3732 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
3733 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
f049052b
BG		 3734 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3735 "dot11RSNAConfigPMKLifetime");
6fc6879b
JM		 3736 return -1;
3737 }
3738
3739 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
3740 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
3741 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
f049052b 3742 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
6fc6879b
JM		 3743 "dot11RSNAConfigPMKReauthThreshold");
3744 return -1;
3745 }
3746
3747 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
3748 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
3749 wpa_s->conf->dot11RSNAConfigSATimeout)) {
f049052b
BG		 3750 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3751 "dot11RSNAConfigSATimeout");
6fc6879b
JM		 3752 return -1;
3753 }
3754
6bf731e8
CL		 3755 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
3756 &wpa_s->hw.num_modes,
3757 &wpa_s->hw.flags);
3758
6cbdb0c5
JM		 3759 capa_res = wpa_drv_get_capa(wpa_s, &capa);
3760 if (capa_res == 0) {
c58ab8f2 3761 wpa_s->drv_capa_known = 1;
814782b9 3762 wpa_s->drv_flags = capa.flags;
349493bd 3763 wpa_s->drv_enc = capa.enc;
04ee647d 3764 wpa_s->drv_smps_modes = capa.smps_modes;
4f73d88a 3765 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
814782b9 3766 wpa_s->max_scan_ssids = capa.max_scan_ssids;
cbdf3507
LC		 3767 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
3768 wpa_s->sched_scan_supported = capa.sched_scan_supported;
b59e6f26 3769 wpa_s->max_match_sets = capa.max_match_sets;
814782b9 3770 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
c4ea4c5c 3771 wpa_s->max_stations = capa.max_stations;
8cd6b7bc
JB		 3772 wpa_s->extended_capa = capa.extended_capa;
3773 wpa_s->extended_capa_mask = capa.extended_capa_mask;
3774 wpa_s->extended_capa_len = capa.extended_capa_len;
4752147d
IP		 3775 wpa_s->num_multichan_concurrent =
3776 capa.num_multichan_concurrent;
814782b9
JM		 3777 }
3778 if (wpa_s->max_remain_on_chan == 0)
3779 wpa_s->max_remain_on_chan = 1000;
3780
c68f6200
AS		 3781 /*
3782 * Only take p2p_mgmt parameters when P2P Device is supported.
3783 * Doing it here as it determines whether l2_packet_init() will be done
3784 * during wpa_supplicant_driver_init().
3785 */
3786 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
3787 wpa_s->p2p_mgmt = iface->p2p_mgmt;
3788 else
3789 iface->p2p_mgmt = 1;
3790
4752147d
IP		 3791 if (wpa_s->num_multichan_concurrent == 0)
3792 wpa_s->num_multichan_concurrent = 1;
3793
6fc6879b
JM		 3794 if (wpa_supplicant_driver_init(wpa_s) < 0)
3795 return -1;
3796
281ff0aa 3797#ifdef CONFIG_TDLS
1c42b42f
JM		 3798 if ((!iface->p2p_mgmt ||
3799 !(wpa_s->drv_flags &
3800 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3801 wpa_tdls_init(wpa_s->wpa))
281ff0aa
GP		 3802 return -1;
3803#endif /* CONFIG_TDLS */
3804
315ce40a
JM		 3805 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3806 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
f049052b 3807 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
6d158490
LR		 3808 return -1;
3809 }
3810
116654ce
JM		 3811 if (wpas_wps_init(wpa_s))
3812 return -1;
3813
6fc6879b
JM		 3814 if (wpa_supplicant_init_eapol(wpa_s) < 0)
3815 return -1;
3816 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3817
3818 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3819 if (wpa_s->ctrl_iface == NULL) {
3820 wpa_printf(MSG_ERROR,
3821 "Failed to initialize control interface '%s'.\n"
3822 "You may have another wpa_supplicant process "
3823 "already running or the file was\n"
3824 "left by an unclean termination of wpa_supplicant "
3825 "in which case you will need\n"
3826 "to manually remove this file before starting "
3827 "wpa_supplicant again.\n",
3828 wpa_s->conf->ctrl_interface);
3829 return -1;
3830 }
3831
04ea7b79
JM		 3832 wpa_s->gas = gas_query_init(wpa_s);
3833 if (wpa_s->gas == NULL) {
3834 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
3835 return -1;
3836 }
3837
c68f6200 3838 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
f049052b 3839 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
b22128ef
JM		 3840 return -1;
3841 }
b22128ef 3842
83922c2d
JM		 3843 if (wpa_bss_init(wpa_s) < 0)
3844 return -1;
83922c2d 3845
e4fa8b12
EP		 3846 /*
3847 * Set Wake-on-WLAN triggers, if configured.
3848 * Note: We don't restore/remove the triggers on shutdown (it doesn't
3849 * have effect anyway when the interface is down).
3850 */
6cbdb0c5 3851 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
e4fa8b12
EP		 3852 return -1;
3853
ec7b97ab
JM		 3854#ifdef CONFIG_EAP_PROXY
3855{
3856 size_t len;
07041c6f
NJ		 3857 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
3858 &len);
ec7b97ab
JM		 3859 if (wpa_s->mnc_len > 0) {
3860 wpa_s->imsi[len] = '\0';
3861 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
3862 wpa_s->imsi, wpa_s->mnc_len);
3863 } else {
3864 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
3865 }
3866}
3867#endif /* CONFIG_EAP_PROXY */
3868
f64adcd7
JM		 3869 if (pcsc_reader_init(wpa_s) < 0)
3870 return -1;
3871
306ae225
JM		 3872 if (wpas_init_ext_pw(wpa_s) < 0)
3873 return -1;
3874
6fc6879b
JM		 3875 return 0;
3876}
3877
3878
2ee055b3 3879static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
df509539 3880 int notify, int terminate)
6fc6879b 3881{
26fc96e8
JM		 3882 struct wpa_global *global = wpa_s->global;
3883 struct wpa_supplicant *iface, *prev;
3884
3885 if (wpa_s == wpa_s->parent)
3886 wpas_p2p_group_remove(wpa_s, "*");
3887
3888 iface = global->ifaces;
3889 while (iface) {
3890 if (iface == wpa_s || iface->parent != wpa_s) {
3891 iface = iface->next;
3892 continue;
3893 }
3894 wpa_printf(MSG_DEBUG,
3895 "Remove remaining child interface %s from parent %s",
3896 iface->ifname, wpa_s->ifname);
3897 prev = iface;
3898 iface = iface->next;
3899 wpa_supplicant_remove_iface(global, prev, terminate);
3900 }
3901
e679f140 3902 wpa_s->disconnected = 1;
6fc6879b
JM		 3903 if (wpa_s->drv_priv) {
3904 wpa_supplicant_deauthenticate(wpa_s,
3905 WLAN_REASON_DEAUTH_LEAVING);
3906
6fc6879b
JM		 3907 wpa_drv_set_countermeasures(wpa_s, 0);
3908 wpa_clear_keys(wpa_s, NULL);
3909 }
3910
8e56d189 3911 wpa_supplicant_cleanup(wpa_s);
bd10d938 3912 wpas_p2p_deinit_iface(wpa_s);
ab28911d 3913
1f965e62 3914 wpas_ctrl_radio_work_flush(wpa_s);
202dec2a
JM		 3915 radio_remove_interface(wpa_s);
3916
6fc6879b
JM		 3917 if (wpa_s->drv_priv)
3918 wpa_drv_deinit(wpa_s);
2523ff6e
DS		 3919
3920 if (notify)
3921 wpas_notify_iface_removed(wpa_s);
f0811516
DS		 3922
3923 if (terminate)
3924 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
3925
3926 if (wpa_s->ctrl_iface) {
3927 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3928 wpa_s->ctrl_iface = NULL;
3929 }
3930
3931 if (wpa_s->conf != NULL) {
3932 wpa_config_free(wpa_s->conf);
3933 wpa_s->conf = NULL;
3934 }
18e00b5e
JM		 3935
3936 os_free(wpa_s);
6fc6879b
JM		 3937}
3938
3939
3940/**
3941 * wpa_supplicant_add_iface - Add a new network interface
3942 * @global: Pointer to global data from wpa_supplicant_init()
3943 * @iface: Interface configuration options
3944 * Returns: Pointer to the created interface or %NULL on failure
3945 *
3946 * This function is used to add new network interfaces for %wpa_supplicant.
3947 * This can be called before wpa_supplicant_run() to add interfaces before the
3948 * main event loop has been started. In addition, new interfaces can be added
3949 * dynamically while %wpa_supplicant is already running. This could happen,
3950 * e.g., when a hotplug network adapter is inserted.
3951 */
3952struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
3953 struct wpa_interface *iface)
3954{
3955 struct wpa_supplicant *wpa_s;
d27df100 3956 struct wpa_interface t_iface;
8e56d189 3957 struct wpa_ssid *ssid;
6fc6879b
JM		 3958
3959 if (global == NULL || iface == NULL)
3960 return NULL;
3961
3962 wpa_s = wpa_supplicant_alloc();
3963 if (wpa_s == NULL)
3964 return NULL;
3965
d8222ae3
JM		 3966 wpa_s->global = global;
3967
d27df100
JM		 3968 t_iface = *iface;
3969 if (global->params.override_driver) {
3970 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
3971 "('%s' -> '%s')",
3972 iface->driver, global->params.override_driver);
3973 t_iface.driver = global->params.override_driver;
3974 }
3975 if (global->params.override_ctrl_interface) {
3976 wpa_printf(MSG_DEBUG, "Override interface parameter: "
3977 "ctrl_interface ('%s' -> '%s')",
3978 iface->ctrl_interface,
3979 global->params.override_ctrl_interface);
3980 t_iface.ctrl_interface =
3981 global->params.override_ctrl_interface;
3982 }
3983 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
6fc6879b
JM		 3984 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
3985 iface->ifname);
df509539 3986 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
6fc6879b
JM		 3987 return NULL;
3988 }
3989
21efc940
TB		 3990 if (iface->p2p_mgmt == 0) {
3991 /* Notify the control interfaces about new iface */
3992 if (wpas_notify_iface_added(wpa_s)) {
3993 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
3994 return NULL;
3995 }
1bd3f426 3996
21efc940
TB		 3997 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3998 wpas_notify_network_added(wpa_s, ssid);
3999 }
8e56d189 4000
6fc6879b
JM		 4001 wpa_s->next = global->ifaces;
4002 global->ifaces = wpa_s;
4003
f049052b 4004 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
99218999 4005 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
6fc6879b 4006
c3c4b3ed
JM		 4007#ifdef CONFIG_P2P
4008 if (wpa_s->global->p2p == NULL &&
4009 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
4010 wpas_p2p_add_p2pdev_interface(wpa_s, iface->conf_p2p_dev) < 0) {
4011 wpa_printf(MSG_INFO,
4012 "P2P: Failed to enable P2P Device interface");
4013 /* Try to continue without. P2P will be disabled. */
4014 }
4015#endif /* CONFIG_P2P */
4016
6fc6879b
JM		 4017 return wpa_s;
4018}
4019
4020
4021/**
4022 * wpa_supplicant_remove_iface - Remove a network interface
4023 * @global: Pointer to global data from wpa_supplicant_init()
4024 * @wpa_s: Pointer to the network interface to be removed
4025 * Returns: 0 if interface was removed, -1 if interface was not found
4026 *
4027 * This function can be used to dynamically remove network interfaces from
4028 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
4029 * addition, this function is used to remove all remaining interfaces when
4030 * %wpa_supplicant is terminated.
4031 */
4032int wpa_supplicant_remove_iface(struct wpa_global *global,
df509539
DS		 4033 struct wpa_supplicant *wpa_s,
4034 int terminate)
6fc6879b
JM		 4035{
4036 struct wpa_supplicant *prev;
4037
4038 /* Remove interface from the global list of interfaces */
4039 prev = global->ifaces;
4040 if (prev == wpa_s) {
4041 global->ifaces = wpa_s->next;
4042 } else {
4043 while (prev && prev->next != wpa_s)
4044 prev = prev->next;
4045 if (prev == NULL)
4046 return -1;
4047 prev->next = wpa_s->next;
4048 }
4049
f049052b 4050 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
6fc6879b 4051
b22128ef
JM		 4052 if (global->p2p_group_formation == wpa_s)
4053 global->p2p_group_formation = NULL;
dbca75f8
JM		 4054 if (global->p2p_invite_group == wpa_s)
4055 global->p2p_invite_group = NULL;
df509539 4056 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
6fc6879b
JM		 4057
4058 return 0;
4059}
4060
4061
cf83fb0b
PS		 4062/**
4063 * wpa_supplicant_get_eap_mode - Get the current EAP mode
4064 * @wpa_s: Pointer to the network interface
4065 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
4066 */
4067const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
4068{
4069 const char *eapol_method;
4070
4071 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
4072 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
4073 return "NO-EAP";
4074 }
4075
4076 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
4077 if (eapol_method == NULL)
4078 return "UNKNOWN-EAP";
4079
4080 return eapol_method;
4081}
4082
4083
6fc6879b
JM		 4084/**
4085 * wpa_supplicant_get_iface - Get a new network interface
4086 * @global: Pointer to global data from wpa_supplicant_init()
4087 * @ifname: Interface name
4088 * Returns: Pointer to the interface or %NULL if not found
4089 */
4090struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
4091 const char *ifname)
4092{
4093 struct wpa_supplicant *wpa_s;
4094
4095 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4096 if (os_strcmp(wpa_s->ifname, ifname) == 0)
4097 return wpa_s;
4098 }
4099 return NULL;
4100}
4101
4102
50b16da1 4103#ifndef CONFIG_NO_WPA_MSG
4f1495ae
BG		 4104static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
4105{
4106 struct wpa_supplicant *wpa_s = ctx;
4107 if (wpa_s == NULL)
4108 return NULL;
4109 return wpa_s->ifname;
4110}
50b16da1 4111#endif /* CONFIG_NO_WPA_MSG */
4f1495ae
BG		 4112
4113
6fc6879b
JM		 4114/**
4115 * wpa_supplicant_init - Initialize %wpa_supplicant
4116 * @params: Parameters for %wpa_supplicant
4117 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
4118 *
4119 * This function is used to initialize %wpa_supplicant. After successful
4120 * initialization, the returned data pointer can be used to add and remove
4121 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
4122 */
4123struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
4124{
4125 struct wpa_global *global;
ac305589 4126 int ret, i;
6fc6879b
JM		 4127
4128 if (params == NULL)
4129 return NULL;
4130
39e7d718
JM		 4131#ifdef CONFIG_DRIVER_NDIS
4132 {
4133 void driver_ndis_init_ops(void);
4134 driver_ndis_init_ops();
4135 }
4136#endif /* CONFIG_DRIVER_NDIS */
4137
50b16da1 4138#ifndef CONFIG_NO_WPA_MSG
4f1495ae 4139 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
50b16da1 4140#endif /* CONFIG_NO_WPA_MSG */
4f1495ae 4141
6fc6879b 4142 wpa_debug_open_file(params->wpa_debug_file_path);
daa70d49
SL		 4143 if (params->wpa_debug_syslog)
4144 wpa_debug_open_syslog();
4f68895e
JB		 4145 if (params->wpa_debug_tracing) {
4146 ret = wpa_debug_open_linux_tracing();
4147 if (ret) {
4148 wpa_printf(MSG_ERROR,
4149 "Failed to enable trace logging");
4150 return NULL;
4151 }
4152 }
6fc6879b 4153
12760815 4154 ret = eap_register_methods();
6fc6879b
JM		 4155 if (ret) {
4156 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
4157 if (ret == -2)
4158 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
4159 "the same EAP type.");
4160 return NULL;
4161 }
4162
4163 global = os_zalloc(sizeof(*global));
4164 if (global == NULL)
4165 return NULL;
b22128ef
JM		 4166 dl_list_init(&global->p2p_srv_bonjour);
4167 dl_list_init(&global->p2p_srv_upnp);
6fc6879b
JM		 4168 global->params.daemonize = params->daemonize;
4169 global->params.wait_for_monitor = params->wait_for_monitor;
4170 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
4171 if (params->pid_file)
4172 global->params.pid_file = os_strdup(params->pid_file);
4173 if (params->ctrl_interface)
4174 global->params.ctrl_interface =
4175 os_strdup(params->ctrl_interface);
29257565
JM		 4176 if (params->ctrl_interface_group)
4177 global->params.ctrl_interface_group =
4178 os_strdup(params->ctrl_interface_group);
d27df100
JM		 4179 if (params->override_driver)
4180 global->params.override_driver =
4181 os_strdup(params->override_driver);
4182 if (params->override_ctrl_interface)
4183 global->params.override_ctrl_interface =
4184 os_strdup(params->override_ctrl_interface);
6fc6879b
JM		 4185 wpa_debug_level = global->params.wpa_debug_level =
4186 params->wpa_debug_level;
4187 wpa_debug_show_keys = global->params.wpa_debug_show_keys =
4188 params->wpa_debug_show_keys;
4189 wpa_debug_timestamp = global->params.wpa_debug_timestamp =
4190 params->wpa_debug_timestamp;
4191
f19858f5
JM		 4192 wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
4193
0456ea16 4194 if (eloop_init()) {
6fc6879b
JM		 4195 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
4196 wpa_supplicant_deinit(global);
4197 return NULL;
4198 }
4199
38e24575 4200 random_init(params->entropy_file);
d47fa330 4201
6fc6879b
JM		 4202 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
4203 if (global->ctrl_iface == NULL) {
4204 wpa_supplicant_deinit(global);
4205 return NULL;
4206 }
4207
dc461de4
WS		 4208 if (wpas_notify_supplicant_initialized(global)) {
4209 wpa_supplicant_deinit(global);
4210 return NULL;
6fc6879b
JM		 4211 }
4212
c5121837 4213 for (i = 0; wpa_drivers[i]; i++)
ac305589
JM		 4214 global->drv_count++;
4215 if (global->drv_count == 0) {
4216 wpa_printf(MSG_ERROR, "No drivers enabled");
4217 wpa_supplicant_deinit(global);
4218 return NULL;
4219 }
4220 global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
4221 if (global->drv_priv == NULL) {
4222 wpa_supplicant_deinit(global);
4223 return NULL;
4224 }
ac305589 4225
9675ce35
JM		 4226#ifdef CONFIG_WIFI_DISPLAY
4227 if (wifi_display_init(global) < 0) {
4228 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
4229 wpa_supplicant_deinit(global);
4230 return NULL;
4231 }
4232#endif /* CONFIG_WIFI_DISPLAY */
4233
6fc6879b
JM		 4234 return global;
4235}
4236
4237
4238/**
4239 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
4240 * @global: Pointer to global data from wpa_supplicant_init()
4241 * Returns: 0 after successful event loop run, -1 on failure
4242 *
4243 * This function starts the main event loop and continues running as long as
4244 * there are any remaining events. In most cases, this function is running as
4245 * long as the %wpa_supplicant process in still in use.
4246 */
4247int wpa_supplicant_run(struct wpa_global *global)
4248{
4249 struct wpa_supplicant *wpa_s;
4250
4251 if (global->params.daemonize &&
4252 wpa_supplicant_daemon(global->params.pid_file))
4253 return -1;
4254
4255 if (global->params.wait_for_monitor) {
4256 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
4257 if (wpa_s->ctrl_iface)
4258 wpa_supplicant_ctrl_iface_wait(
4259 wpa_s->ctrl_iface);
4260 }
4261
0456ea16
JM		 4262 eloop_register_signal_terminate(wpa_supplicant_terminate, global);
4263 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
6fc6879b
JM		 4264
4265 eloop_run();
4266
4267 return 0;
4268}
4269
4270
4271/**
4272 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
4273 * @global: Pointer to global data from wpa_supplicant_init()
4274 *
4275 * This function is called to deinitialize %wpa_supplicant and to free all
4276 * allocated resources. Remaining network interfaces will also be removed.
4277 */
4278void wpa_supplicant_deinit(struct wpa_global *global)
4279{
ac305589
JM		 4280 int i;
4281
6fc6879b
JM		 4282 if (global == NULL)
4283 return;
4284
9675ce35
JM		 4285#ifdef CONFIG_WIFI_DISPLAY
4286 wifi_display_deinit(global);
4287#endif /* CONFIG_WIFI_DISPLAY */
b22128ef 4288
6fc6879b 4289 while (global->ifaces)
df509539 4290 wpa_supplicant_remove_iface(global, global->ifaces, 1);
6fc6879b
JM		 4291
4292 if (global->ctrl_iface)
4293 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
dc461de4
WS		 4294
4295 wpas_notify_supplicant_deinitialized(global);
6fc6879b
JM		 4296
4297 eap_peer_unregister_methods();
3ec97afe
JM		 4298#ifdef CONFIG_AP
4299 eap_server_unregister_methods();
4300#endif /* CONFIG_AP */
6fc6879b 4301
c5121837 4302 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
ac305589
JM		 4303 if (!global->drv_priv[i])
4304 continue;
c5121837 4305 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
ac305589
JM		 4306 }
4307 os_free(global->drv_priv);
4308
d47fa330
JM		 4309 random_deinit();
4310
6fc6879b
JM		 4311 eloop_destroy();
4312
4313 if (global->params.pid_file) {
4314 os_daemonize_terminate(global->params.pid_file);
4315 os_free(global->params.pid_file);
4316 }
4317 os_free(global->params.ctrl_interface);
29257565 4318 os_free(global->params.ctrl_interface_group);
d27df100
JM		 4319 os_free(global->params.override_driver);
4320 os_free(global->params.override_ctrl_interface);
6fc6879b 4321
af8a827b 4322 os_free(global->p2p_disallow_freq.range);
253f2e37 4323 os_free(global->p2p_go_avoid_freq.range);
01a57fe4 4324 os_free(global->add_psk);
6f3bc72b 4325
6fc6879b 4326 os_free(global);
daa70d49 4327 wpa_debug_close_syslog();
6fc6879b 4328 wpa_debug_close_file();
4f68895e 4329 wpa_debug_close_linux_tracing();
6fc6879b 4330}
611aea7d
JM		 4331
4332
4333void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
4334{
849b5dc7
JM		 4335 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
4336 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
4337 char country[3];
4338 country[0] = wpa_s->conf->country[0];
4339 country[1] = wpa_s->conf->country[1];
4340 country[2] = '\0';
4341 if (wpa_drv_set_country(wpa_s, country) < 0) {
4342 wpa_printf(MSG_ERROR, "Failed to set country code "
4343 "'%s'", country);
4344 }
4345 }
4346
306ae225
JM		 4347 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
4348 wpas_init_ext_pw(wpa_s);
4349
611aea7d
JM		 4350#ifdef CONFIG_WPS
4351 wpas_wps_update_config(wpa_s);
4352#endif /* CONFIG_WPS */
b22128ef 4353 wpas_p2p_update_config(wpa_s);
611aea7d
JM		 4354 wpa_s->conf->changed_parameters = 0;
4355}
2f9c6aa6
JM		 4356
4357
0fb337c1
JM		 4358static void add_freq(int *freqs, int *num_freqs, int freq)
4359{
4360 int i;
4361
4362 for (i = 0; i < *num_freqs; i++) {
4363 if (freqs[i] == freq)
4364 return;
4365 }
4366
4367 freqs[*num_freqs] = freq;
4368 (*num_freqs)++;
4369}
4370
4371
4372static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
4373{
4374 struct wpa_bss *bss, *cbss;
4375 const int max_freqs = 10;
4376 int *freqs;
4377 int num_freqs = 0;
4378
4379 freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
4380 if (freqs == NULL)
4381 return NULL;
4382
4383 cbss = wpa_s->current_bss;
4384
4385 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
4386 if (bss == cbss)
4387 continue;
4388 if (bss->ssid_len == cbss->ssid_len &&
4389 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
4390 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
4391 add_freq(freqs, &num_freqs, bss->freq);
4392 if (num_freqs == max_freqs)
4393 break;
4394 }
4395 }
4396
4397 if (num_freqs == 0) {
4398 os_free(freqs);
4399 freqs = NULL;
4400 }
4401
4402 return freqs;
4403}
4404
4405
4406void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
4407{
4408 int timeout;
4409 int count;
4410 int *freqs = NULL;
4411
6ac4b15e
JM		 4412 wpas_connect_work_done(wpa_s);
4413
5fd9fb27
JM		 4414 /*
4415 * Remove possible authentication timeout since the connection failed.
4416 */
4417 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
4418
0cdb93fe
JM		 4419 if (wpa_s->disconnected) {
4420 /*
4421 * There is no point in blacklisting the AP if this event is
4422 * generated based on local request to disconnect.
4423 */
4424 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
4425 "indication since interface has been put into "
4426 "disconnected state");
4427 return;
4428 }
4429
0fb337c1
JM		 4430 /*
4431 * Add the failed BSSID into the blacklist and speed up next scan
4432 * attempt if there could be other APs that could accept association.
4433 * The current blacklist count indicates how many times we have tried
4434 * connecting to this AP and multiple attempts mean that other APs are
4435 * either not available or has already been tried, so that we can start
4436 * increasing the delay here to avoid constant scanning.
4437 */
4438 count = wpa_blacklist_add(wpa_s, bssid);
4439 if (count == 1 && wpa_s->current_bss) {
4440 /*
4441 * This BSS was not in the blacklist before. If there is
4442 * another BSS available for the same ESS, we should try that
4443 * next. Otherwise, we may as well try this one once more
4444 * before allowing other, likely worse, ESSes to be considered.
4445 */
4446 freqs = get_bss_freqs_in_ess(wpa_s);
4447 if (freqs) {
f049052b
BG		 4448 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
4449 "has been seen; try it next");
0fb337c1
JM		 4450 wpa_blacklist_add(wpa_s, bssid);
4451 /*
4452 * On the next scan, go through only the known channels
4453 * used in this ESS based on previous scans to speed up
4454 * common load balancing use case.
4455 */
4456 os_free(wpa_s->next_scan_freqs);
4457 wpa_s->next_scan_freqs = freqs;
4458 }
4459 }
4460
f1a52633
JM		 4461 /*
4462 * Add previous failure count in case the temporary blacklist was
4463 * cleared due to no other BSSes being available.
4464 */
4465 count += wpa_s->extra_blacklist_count;
4466
dd579704
JM		 4467 if (count > 3 && wpa_s->current_ssid) {
4468 wpa_printf(MSG_DEBUG, "Continuous association failures - "
4469 "consider temporary network disabling");
b19c098e 4470 wpas_auth_failed(wpa_s, "CONN_FAILED");
dd579704
JM		 4471 }
4472
0fb337c1
JM		 4473 switch (count) {
4474 case 1:
4475 timeout = 100;
4476 break;
4477 case 2:
4478 timeout = 500;
4479 break;
4480 case 3:
4481 timeout = 1000;
4482 break;
f1a52633 4483 case 4:
0fb337c1 4484 timeout = 5000;
f1a52633
JM		 4485 break;
4486 default:
4487 timeout = 10000;
4488 break;
0fb337c1
JM		 4489 }
4490
f1a52633
JM		 4491 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
4492 "ms", count, timeout);
4493
0fb337c1
JM		 4494 /*
4495 * TODO: if more than one possible AP is available in scan results,
4496 * could try the other ones before requesting a new scan.
4497 */
4498 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
4499 1000 * (timeout % 1000));
4500}
22628eca
JM		 4501
4502
4503int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
4504{
4505 return wpa_s->conf->ap_scan == 2 ||
4506 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
4507}
d2118814
JM		 4508
4509
4510#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
4511int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
4512 struct wpa_ssid *ssid,
4513 const char *field,
4514 const char *value)
4515{
4516#ifdef IEEE8021X_EAPOL
4517 struct eap_peer_config *eap = &ssid->eap;
4518
4519 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
4520 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
4521 (const u8 *) value, os_strlen(value));
4522
4523 switch (wpa_supplicant_ctrl_req_from_string(field)) {
4524 case WPA_CTRL_REQ_EAP_IDENTITY:
4525 os_free(eap->identity);
4526 eap->identity = (u8 *) os_strdup(value);
4527 eap->identity_len = os_strlen(value);
4528 eap->pending_req_identity = 0;
4529 if (ssid == wpa_s->current_ssid)
4530 wpa_s->reassociate = 1;
4531 break;
4532 case WPA_CTRL_REQ_EAP_PASSWORD:
19c48da0 4533 bin_clear_free(eap->password, eap->password_len);
d2118814
JM		 4534 eap->password = (u8 *) os_strdup(value);
4535 eap->password_len = os_strlen(value);
4536 eap->pending_req_password = 0;
4537 if (ssid == wpa_s->current_ssid)
4538 wpa_s->reassociate = 1;
4539 break;
4540 case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
19c48da0 4541 bin_clear_free(eap->new_password, eap->new_password_len);
d2118814
JM		 4542 eap->new_password = (u8 *) os_strdup(value);
4543 eap->new_password_len = os_strlen(value);
4544 eap->pending_req_new_password = 0;
4545 if (ssid == wpa_s->current_ssid)
4546 wpa_s->reassociate = 1;
4547 break;
4548 case WPA_CTRL_REQ_EAP_PIN:
19c48da0 4549 str_clear_free(eap->pin);
d2118814
JM		 4550 eap->pin = os_strdup(value);
4551 eap->pending_req_pin = 0;
4552 if (ssid == wpa_s->current_ssid)
4553 wpa_s->reassociate = 1;
4554 break;
4555 case WPA_CTRL_REQ_EAP_OTP:
19c48da0 4556 bin_clear_free(eap->otp, eap->otp_len);
d2118814
JM		 4557 eap->otp = (u8 *) os_strdup(value);
4558 eap->otp_len = os_strlen(value);
4559 os_free(eap->pending_req_otp);
4560 eap->pending_req_otp = NULL;
4561 eap->pending_req_otp_len = 0;
4562 break;
4563 case WPA_CTRL_REQ_EAP_PASSPHRASE:
19c48da0
JM		 4564 str_clear_free(eap->private_key_passwd);
4565 eap->private_key_passwd = os_strdup(value);
d2118814
JM		 4566 eap->pending_req_passphrase = 0;
4567 if (ssid == wpa_s->current_ssid)
4568 wpa_s->reassociate = 1;
4569 break;
a5d44ac0 4570 case WPA_CTRL_REQ_SIM:
19c48da0 4571 str_clear_free(eap->external_sim_resp);
a5d44ac0
JM		 4572 eap->external_sim_resp = os_strdup(value);
4573 break;
d2118814
JM		 4574 default:
4575 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
4576 return -1;
4577 }
4578
4579 return 0;
4580#else /* IEEE8021X_EAPOL */
4581 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
4582 return -1;
4583#endif /* IEEE8021X_EAPOL */
4584}
4585#endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
349493bd
JM		 4586
4587
4588int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
4589{
4590 int i;
4591 unsigned int drv_enc;
4592
4593 if (ssid == NULL)
4594 return 1;
4595
4596 if (ssid->disabled)
4597 return 1;
4598
4599 if (wpa_s && wpa_s->drv_capa_known)
4600 drv_enc = wpa_s->drv_enc;
4601 else
4602 drv_enc = (unsigned int) -1;
4603
4604 for (i = 0; i < NUM_WEP_KEYS; i++) {
4605 size_t len = ssid->wep_key_len[i];
4606 if (len == 0)
4607 continue;
4608 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
4609 continue;
4610 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
4611 continue;
4612 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
4613 continue;
4614 return 1; /* invalid WEP key */
4615 }
4616
9173b16f 4617 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
759ff2f0 4618 (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk)
2518aad3
JM		 4619 return 1;
4620
349493bd
JM		 4621 return 0;
4622}
b9cfc09a
JJ		 4623
4624
4625int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
4626{
4627 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
4628 return 1;
4629 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
4630 return 0;
4631 return -1;
4632}
00e5e3d5
JM		 4633
4634
b19c098e 4635void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
00e5e3d5
JM		 4636{
4637 struct wpa_ssid *ssid = wpa_s->current_ssid;
4638 int dur;
4e1eae1d 4639 struct os_reltime now;
00e5e3d5
JM		 4640
4641 if (ssid == NULL) {
4642 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
4643 "SSID block");
4644 return;
4645 }
4646
4647 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
4648 return;
4649
4650 ssid->auth_failures++;
cbf41ca7
SL		 4651
4652#ifdef CONFIG_P2P
4653 if (ssid->p2p_group &&
4654 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
4655 /*
4656 * Skip the wait time since there is a short timeout on the
4657 * connection to a P2P group.
4658 */
4659 return;
4660 }
4661#endif /* CONFIG_P2P */
4662
00e5e3d5
JM		 4663 if (ssid->auth_failures > 50)
4664 dur = 300;
00e5e3d5 4665 else if (ssid->auth_failures > 10)
8a77f1be 4666 dur = 120;
00e5e3d5 4667 else if (ssid->auth_failures > 5)
8a77f1be
JM		 4668 dur = 90;
4669 else if (ssid->auth_failures > 3)
4670 dur = 60;
4671 else if (ssid->auth_failures > 2)
00e5e3d5
JM		 4672 dur = 30;
4673 else if (ssid->auth_failures > 1)
4674 dur = 20;
4675 else
4676 dur = 10;
4677
8a77f1be
JM		 4678 if (ssid->auth_failures > 1 &&
4679 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
4680 dur += os_random() % (ssid->auth_failures * 10);
4681
4e1eae1d 4682 os_get_reltime(&now);
00e5e3d5
JM		 4683 if (now.sec + dur <= ssid->disabled_until.sec)
4684 return;
4685
4686 ssid->disabled_until.sec = now.sec + dur;
4687
4688 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
b19c098e 4689 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
00e5e3d5 4690 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
b19c098e 4691 ssid->auth_failures, dur, reason);
00e5e3d5
JM		 4692}
4693
4694
4695void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
4696 struct wpa_ssid *ssid, int clear_failures)
4697{
4698 if (ssid == NULL)
4699 return;
4700
4701 if (ssid->disabled_until.sec) {
4702 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
4703 "id=%d ssid=\"%s\"",
4704 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
4705 }
4706 ssid->disabled_until.sec = 0;
4707 ssid->disabled_until.usec = 0;
4708 if (clear_failures)
4709 ssid->auth_failures = 0;
4710}
6407f413
JM		 4711
4712
4713int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
4714{
4715 size_t i;
4716
4717 if (wpa_s->disallow_aps_bssid == NULL)
4718 return 0;
4719
4720 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
4721 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
4722 bssid, ETH_ALEN) == 0)
4723 return 1;
4724 }
4725
4726 return 0;
4727}
4728
4729
4730int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
4731 size_t ssid_len)
4732{
4733 size_t i;
4734
4735 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
4736 return 0;
4737
4738 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
4739 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
4740 if (ssid_len == s->ssid_len &&
4741 os_memcmp(ssid, s->ssid, ssid_len) == 0)
4742 return 1;
4743 }
4744
4745 return 0;
4746}
9796a86c
JM		 4747
4748
4749/**
4750 * wpas_request_connection - Request a new connection
4751 * @wpa_s: Pointer to the network interface
4752 *
4753 * This function is used to request a new connection to be found. It will mark
4754 * the interface to allow reassociation and request a new scan to find a
4755 * suitable network to connect to.
4756 */
4757void wpas_request_connection(struct wpa_supplicant *wpa_s)
4758{
4759 wpa_s->normal_scans = 0;
4760 wpa_supplicant_reinit_autoscan(wpa_s);
4761 wpa_s->extra_blacklist_count = 0;
4762 wpa_s->disconnected = 0;
4763 wpa_s->reassociate = 1;
5e24beae
MH		 4764
4765 if (wpa_supplicant_fast_associate(wpa_s) != 1)
4766 wpa_supplicant_req_scan(wpa_s, 0, 0);
9796a86c 4767}
36b9883d
DG		 4768
4769
a0c90bb0
IP		 4770void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
4771 struct wpa_used_freq_data *freqs_data,
4772 unsigned int len)
4773{
4774 unsigned int i;
4775
4776 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
4777 len, title);
4778 for (i = 0; i < len; i++) {
4779 struct wpa_used_freq_data *cur = &freqs_data[i];
4780 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
4781 i, cur->freq, cur->flags);
4782 }
4783}
4784
4785
53c5dfc2
IP		 4786/*
4787 * Find the operating frequencies of any of the virtual interfaces that
a0c90bb0
IP		 4788 * are using the same radio as the current interface, and in addition, get
4789 * information about the interface types that are using the frequency.
53c5dfc2 4790 */
a0c90bb0
IP		 4791int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
4792 struct wpa_used_freq_data *freqs_data,
4793 unsigned int len)
53c5dfc2 4794{
53c5dfc2
IP		 4795 struct wpa_supplicant *ifs;
4796 u8 bssid[ETH_ALEN];
4797 int freq;
4798 unsigned int idx = 0, i;
4799
217cf499
JM		 4800 wpa_dbg(wpa_s, MSG_DEBUG,
4801 "Determining shared radio frequencies (max len %u)", len);
a0c90bb0 4802 os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
53c5dfc2 4803
0ad3b9c4
JM		 4804 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
4805 radio_list) {
a0c90bb0
IP		 4806 if (idx == len)
4807 break;
4808
53c5dfc2
IP		 4809 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
4810 continue;
4811
4812 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
4813 ifs->current_ssid->mode == WPAS_MODE_P2P_GO)
4814 freq = ifs->current_ssid->frequency;
4815 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
4816 freq = ifs->assoc_freq;
4817 else
4818 continue;
4819
4820 /* Hold only distinct freqs */
4821 for (i = 0; i < idx; i++)
a0c90bb0 4822 if (freqs_data[i].freq == freq)
53c5dfc2
IP		 4823 break;
4824
4825 if (i == idx)
a0c90bb0
IP		 4826 freqs_data[idx++].freq = freq;
4827
4828 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
4829 freqs_data[i].flags = ifs->current_ssid->p2p_group ?
4830 WPA_FREQ_USED_BY_P2P_CLIENT :
4831 WPA_FREQ_USED_BY_INFRA_STATION;
4832 }
53c5dfc2 4833 }
217cf499 4834
a0c90bb0 4835 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
53c5dfc2
IP		 4836 return idx;
4837}
a0c90bb0
IP		 4838
4839
4840/*
4841 * Find the operating frequencies of any of the virtual interfaces that
4842 * are using the same radio as the current interface.
4843 */
4844int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
4845 int *freq_array, unsigned int len)
4846{
4847 struct wpa_used_freq_data *freqs_data;
4848 int num, i;
4849
4850 os_memset(freq_array, 0, sizeof(int) * len);
4851
4852 freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
4853 if (!freqs_data)
4854 return -1;
4855
4856 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
4857 for (i = 0; i < num; i++)
4858 freq_array[i] = freqs_data[i].freq;
4859
4860 os_free(freqs_data);
4861
4862 return num;
4863}
Unnamed repository; edit this file 'description' to name the repository.