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