blob: fffecd41fbe4f6008f893ad808f9ccd931f7099a [file] [log] [blame]
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001/*
2 * WPA Supplicant
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003 * Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi>
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004 *
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08005 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07007 *
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"
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080017#include "crypto/sha1.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070018#include "eapol_supp/eapol_supp_sm.h"
19#include "eap_peer/eap.h"
Dmitry Shmidt34af3062013-07-11 10:46:32 -070020#include "eap_peer/eap_proxy.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070021#include "eap_server/eap_methods.h"
22#include "rsn_supp/wpa.h"
23#include "eloop.h"
24#include "config.h"
Dmitry Shmidt61d9df32012-08-29 16:22:06 -070025#include "utils/ext_password.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070026#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"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070035#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"
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080042#include "gas_query.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070043#include "ap.h"
44#include "p2p_supplicant.h"
Dmitry Shmidt61d9df32012-08-29 16:22:06 -070045#include "wifi_display.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070046#include "notify.h"
47#include "bgscan.h"
Dmitry Shmidt04949592012-07-19 12:16:46 -070048#include "autoscan.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070049#include "bss.h"
50#include "scan.h"
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080051#include "offchannel.h"
Dmitry Shmidt04949592012-07-19 12:16:46 -070052#include "hs20_supplicant.h"
Dmitry Shmidt44c95782013-05-17 09:51:35 -070053#include "wnm_sta.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070054
55const char *wpa_supplicant_version =
56"wpa_supplicant v" VERSION_STR "\n"
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080057"Copyright (c) 2003-2013, Jouni Malinen <j@w1.fi> and contributors";
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070058
59const char *wpa_supplicant_license =
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -080060"This software may be distributed under the terms of the BSD license.\n"
61"See README for more details.\n"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070062#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. */
70const char *wpa_supplicant_full_license1 =
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -080071"";
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070072const char *wpa_supplicant_full_license2 =
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -080073"This software may be distributed under the terms of the BSD license.\n"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070074"\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";
79const 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";
87const 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";
96const 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
107extern int wpa_debug_level;
108extern int wpa_debug_show_keys;
109extern int wpa_debug_timestamp;
110extern struct wpa_driver_ops *wpa_drivers[];
111
112/* Configure default/group WEP keys for static WEP */
113int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
114{
115 int i, set = 0;
116
117 for (i = 0; i < NUM_WEP_KEYS; i++) {
118 if (ssid->wep_key_len[i] == 0)
119 continue;
120
121 set = 1;
122 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
123 i, i == ssid->wep_tx_keyidx, NULL, 0,
124 ssid->wep_key[i], ssid->wep_key_len[i]);
125 }
126
127 return set;
128}
129
130
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700131int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
132 struct wpa_ssid *ssid)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700133{
134 u8 key[32];
135 size_t keylen;
136 enum wpa_alg alg;
137 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 if (ssid->mode != WPAS_MODE_IBSS) {
143 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
144 "IBSS/ad-hoc) for WPA-None", ssid->mode);
145 return -1;
146 }
147
148 if (!ssid->psk_set) {
149 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
150 "WPA-None");
151 return -1;
152 }
153
154 switch (wpa_s->group_cipher) {
155 case WPA_CIPHER_CCMP:
156 os_memcpy(key, ssid->psk, 16);
157 keylen = 16;
158 alg = WPA_ALG_CCMP;
159 break;
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700160 case WPA_CIPHER_GCMP:
161 os_memcpy(key, ssid->psk, 16);
162 keylen = 16;
163 alg = WPA_ALG_GCMP;
164 break;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700165 case WPA_CIPHER_TKIP:
166 /* WPA-None uses the same Michael MIC key for both TX and RX */
167 os_memcpy(key, ssid->psk, 16 + 8);
168 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
169 keylen = 32;
170 alg = WPA_ALG_TKIP;
171 break;
172 default:
173 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
174 "WPA-None", wpa_s->group_cipher);
175 return -1;
176 }
177
178 /* TODO: should actually remember the previously used seq#, both for TX
179 * and RX from each STA.. */
180
181 return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
182}
183
184
185static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
186{
187 struct wpa_supplicant *wpa_s = eloop_ctx;
188 const u8 *bssid = wpa_s->bssid;
189 if (is_zero_ether_addr(bssid))
190 bssid = wpa_s->pending_bssid;
191 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
192 MAC2STR(bssid));
193 wpa_blacklist_add(wpa_s, bssid);
194 wpa_sm_notify_disassoc(wpa_s->wpa);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800195 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700196 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 wpa_supplicant_req_scan(wpa_s, 1, 0);
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700203
Dmitry Shmidt37d4d6a2013-03-18 13:09:42 -0700204 wpas_p2p_continue_after_scan(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700205}
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 */
217void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
218 int sec, int usec)
219{
Dmitry Shmidt68d0e3e2013-10-28 17:59:21 -0700220 if (wpa_s->conf->ap_scan == 0 &&
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700221 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
222 return;
223
224 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
225 "%d usec", sec, usec);
226 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
227 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 */
239void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
240{
241 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
242 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
243 wpa_blacklist_del(wpa_s, wpa_s->bssid);
244}
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 */
254void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
255{
256#ifdef IEEE8021X_EAPOL
257 struct eapol_config eapol_conf;
258 struct wpa_ssid *ssid = wpa_s->current_ssid;
259
260#ifdef CONFIG_IBSS_RSN
261 if (ssid->mode == WPAS_MODE_IBSS &&
262 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
263 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 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
269 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
270 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
271 return;
272 }
273#endif /* CONFIG_IBSS_RSN */
274
275 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
276 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
277
278 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
279 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
280 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
281 else
282 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
283
284 os_memset(&eapol_conf, 0, sizeof(eapol_conf));
285 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
286 eapol_conf.accept_802_1x_keys = 1;
287 eapol_conf.required_keys = 0;
288 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
289 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
290 }
291 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
292 eapol_conf.required_keys |=
293 EAPOL_REQUIRE_KEY_BROADCAST;
294 }
295
Dmitry Shmidt68d0e3e2013-10-28 17:59:21 -0700296 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700297 eapol_conf.required_keys = 0;
298 }
Dmitry Shmidt68d0e3e2013-10-28 17:59:21 -0700299 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700300 eapol_conf.workaround = ssid->eap_workaround;
301 eapol_conf.eap_disabled =
302 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
303 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
304 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
Dmitry Shmidt051af732013-10-22 13:52:46 -0700305 eapol_conf.external_sim = wpa_s->conf->external_sim;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700306 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 */
320void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
321 struct wpa_ssid *ssid)
322{
323 int i;
324
325 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
326 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
327 else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
328 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
329 else
330 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
331 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
332 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
333 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
334 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
335 wpa_s->group_cipher = WPA_CIPHER_NONE;
336 wpa_s->mgmt_group_cipher = 0;
337
338 for (i = 0; i < NUM_WEP_KEYS; i++) {
339 if (ssid->wep_key_len[i] > 5) {
340 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
341 wpa_s->group_cipher = WPA_CIPHER_WEP104;
342 break;
343 } else if (ssid->wep_key_len[i] > 0) {
344 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
345 wpa_s->group_cipher = WPA_CIPHER_WEP40;
346 break;
347 }
348 }
349
350 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
351 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
352 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
353 wpa_s->pairwise_cipher);
354 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
355#ifdef CONFIG_IEEE80211W
356 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
357 wpa_s->mgmt_group_cipher);
358#endif /* CONFIG_IEEE80211W */
359
360 pmksa_cache_clear_current(wpa_s->wpa);
361}
362
363
Dmitry Shmidt04949592012-07-19 12:16:46 -0700364void free_hw_features(struct wpa_supplicant *wpa_s)
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800365{
366 int i;
367 if (wpa_s->hw.modes == NULL)
368 return;
369
370 for (i = 0; i < wpa_s->hw.num_modes; i++) {
371 os_free(wpa_s->hw.modes[i].channels);
372 os_free(wpa_s->hw.modes[i].rates);
373 }
374
375 os_free(wpa_s->hw.modes);
376 wpa_s->hw.modes = NULL;
377}
378
379
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700380static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
381{
382 bgscan_deinit(wpa_s);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700383 autoscan_deinit(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700384 scard_deinit(wpa_s->scard);
385 wpa_s->scard = NULL;
386 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
387 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
388 l2_packet_deinit(wpa_s->l2);
389 wpa_s->l2 = NULL;
390 if (wpa_s->l2_br) {
391 l2_packet_deinit(wpa_s->l2_br);
392 wpa_s->l2_br = NULL;
393 }
394
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700395 if (wpa_s->conf != NULL) {
396 struct wpa_ssid *ssid;
397 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
398 wpas_notify_network_removed(wpa_s, ssid);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700399 }
400
401 os_free(wpa_s->confname);
402 wpa_s->confname = NULL;
403
Jouni Malinen5d1c8ad2013-04-23 12:34:56 -0700404 os_free(wpa_s->confanother);
405 wpa_s->confanother = NULL;
406
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700407 wpa_sm_set_eapol(wpa_s->wpa, NULL);
408 eapol_sm_deinit(wpa_s->eapol);
409 wpa_s->eapol = NULL;
410
411 rsn_preauth_deinit(wpa_s->wpa);
412
413#ifdef CONFIG_TDLS
414 wpa_tdls_deinit(wpa_s->wpa);
415#endif /* CONFIG_TDLS */
416
417 pmksa_candidate_free(wpa_s->wpa);
418 wpa_sm_deinit(wpa_s->wpa);
419 wpa_s->wpa = NULL;
420 wpa_blacklist_clear(wpa_s);
421
422 wpa_bss_deinit(wpa_s);
423
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -0700424 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700425 wpa_supplicant_cancel_scan(wpa_s);
426 wpa_supplicant_cancel_auth_timeout(wpa_s);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800427 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
428#ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
429 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
430 wpa_s, NULL);
431#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700432
433 wpas_wps_deinit(wpa_s);
434
435 wpabuf_free(wpa_s->pending_eapol_rx);
436 wpa_s->pending_eapol_rx = NULL;
437
438#ifdef CONFIG_IBSS_RSN
439 ibss_rsn_deinit(wpa_s->ibss_rsn);
440 wpa_s->ibss_rsn = NULL;
441#endif /* CONFIG_IBSS_RSN */
442
443 sme_deinit(wpa_s);
444
445#ifdef CONFIG_AP
446 wpa_supplicant_ap_deinit(wpa_s);
447#endif /* CONFIG_AP */
448
449#ifdef CONFIG_P2P
450 wpas_p2p_deinit(wpa_s);
451#endif /* CONFIG_P2P */
452
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800453#ifdef CONFIG_OFFCHANNEL
454 offchannel_deinit(wpa_s);
455#endif /* CONFIG_OFFCHANNEL */
456
457 wpa_supplicant_cancel_sched_scan(wpa_s);
458
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700459 os_free(wpa_s->next_scan_freqs);
460 wpa_s->next_scan_freqs = NULL;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800461
462 gas_query_deinit(wpa_s->gas);
463 wpa_s->gas = NULL;
464
465 free_hw_features(wpa_s);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700466
467 os_free(wpa_s->bssid_filter);
468 wpa_s->bssid_filter = NULL;
469
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800470 os_free(wpa_s->disallow_aps_bssid);
471 wpa_s->disallow_aps_bssid = NULL;
472 os_free(wpa_s->disallow_aps_ssid);
473 wpa_s->disallow_aps_ssid = NULL;
474
Dmitry Shmidt04949592012-07-19 12:16:46 -0700475 wnm_bss_keep_alive_deinit(wpa_s);
Dmitry Shmidt44c95782013-05-17 09:51:35 -0700476#ifdef CONFIG_WNM
477 wnm_deallocate_memory(wpa_s);
478#endif /* CONFIG_WNM */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700479
480 ext_password_deinit(wpa_s->ext_pw);
481 wpa_s->ext_pw = NULL;
482
483 wpabuf_free(wpa_s->last_gas_resp);
Dmitry Shmidt9bce59c2012-09-11 15:06:38 -0700484
485 os_free(wpa_s->last_scan_res);
486 wpa_s->last_scan_res = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700487}
488
489
490/**
491 * wpa_clear_keys - Clear keys configured for the driver
492 * @wpa_s: Pointer to wpa_supplicant data
493 * @addr: Previously used BSSID or %NULL if not available
494 *
495 * This function clears the encryption keys that has been previously configured
496 * for the driver.
497 */
498void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
499{
500 if (wpa_s->keys_cleared) {
501 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
502 * timing issues with keys being cleared just before new keys
503 * are set or just after association or something similar. This
504 * shows up in group key handshake failing often because of the
505 * client not receiving the first encrypted packets correctly.
506 * Skipping some of the extra key clearing steps seems to help
507 * in completing group key handshake more reliably. */
508 wpa_dbg(wpa_s, MSG_DEBUG, "No keys have been configured - "
509 "skip key clearing");
510 return;
511 }
512
513 /* MLME-DELETEKEYS.request */
514 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
515 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
516 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
517 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
518#ifdef CONFIG_IEEE80211W
519 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
520 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
521#endif /* CONFIG_IEEE80211W */
522 if (addr) {
523 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
524 0);
525 /* MLME-SETPROTECTION.request(None) */
526 wpa_drv_mlme_setprotection(
527 wpa_s, addr,
528 MLME_SETPROTECTION_PROTECT_TYPE_NONE,
529 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
530 }
531 wpa_s->keys_cleared = 1;
532}
533
534
535/**
536 * wpa_supplicant_state_txt - Get the connection state name as a text string
537 * @state: State (wpa_state; WPA_*)
538 * Returns: The state name as a printable text string
539 */
540const char * wpa_supplicant_state_txt(enum wpa_states state)
541{
542 switch (state) {
543 case WPA_DISCONNECTED:
544 return "DISCONNECTED";
545 case WPA_INACTIVE:
546 return "INACTIVE";
547 case WPA_INTERFACE_DISABLED:
548 return "INTERFACE_DISABLED";
549 case WPA_SCANNING:
550 return "SCANNING";
551 case WPA_AUTHENTICATING:
552 return "AUTHENTICATING";
553 case WPA_ASSOCIATING:
554 return "ASSOCIATING";
555 case WPA_ASSOCIATED:
556 return "ASSOCIATED";
557 case WPA_4WAY_HANDSHAKE:
558 return "4WAY_HANDSHAKE";
559 case WPA_GROUP_HANDSHAKE:
560 return "GROUP_HANDSHAKE";
561 case WPA_COMPLETED:
562 return "COMPLETED";
563 default:
564 return "UNKNOWN";
565 }
566}
567
568
569#ifdef CONFIG_BGSCAN
570
571static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
572{
Dmitry Shmidtb96dad42013-11-05 10:07:29 -0800573 const char *name;
574
575 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
576 name = wpa_s->current_ssid->bgscan;
577 else
578 name = wpa_s->conf->bgscan;
579 if (name == NULL)
580 return;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800581 if (wpas_driver_bss_selection(wpa_s))
582 return;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700583 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
584 return;
585
586 bgscan_deinit(wpa_s);
Dmitry Shmidtb96dad42013-11-05 10:07:29 -0800587 if (wpa_s->current_ssid) {
588 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700589 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
590 "bgscan");
591 /*
592 * Live without bgscan; it is only used as a roaming
593 * optimization, so the initial connection is not
594 * affected.
595 */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700596 } else {
597 struct wpa_scan_results *scan_res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700598 wpa_s->bgscan_ssid = wpa_s->current_ssid;
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700599 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
600 0);
601 if (scan_res) {
602 bgscan_notify_scan(wpa_s, scan_res);
603 wpa_scan_results_free(scan_res);
604 }
605 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700606 } else
607 wpa_s->bgscan_ssid = NULL;
608}
609
610
611static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
612{
613 if (wpa_s->bgscan_ssid != NULL) {
614 bgscan_deinit(wpa_s);
615 wpa_s->bgscan_ssid = NULL;
616 }
617}
618
619#endif /* CONFIG_BGSCAN */
620
621
Dmitry Shmidt04949592012-07-19 12:16:46 -0700622static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
623{
624 if (autoscan_init(wpa_s, 0))
625 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
626}
627
628
629static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
630{
631 autoscan_deinit(wpa_s);
632}
633
634
635void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
636{
637 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
638 wpa_s->wpa_state == WPA_SCANNING) {
639 autoscan_deinit(wpa_s);
640 wpa_supplicant_start_autoscan(wpa_s);
641 }
642}
643
644
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700645/**
646 * wpa_supplicant_set_state - Set current connection state
647 * @wpa_s: Pointer to wpa_supplicant data
648 * @state: The new connection state
649 *
650 * This function is called whenever the connection state changes, e.g.,
651 * association is completed for WPA/WPA2 4-Way Handshake is started.
652 */
653void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
654 enum wpa_states state)
655{
656 enum wpa_states old_state = wpa_s->wpa_state;
657
658 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
659 wpa_supplicant_state_txt(wpa_s->wpa_state),
660 wpa_supplicant_state_txt(state));
661
662 if (state != WPA_SCANNING)
663 wpa_supplicant_notify_scanning(wpa_s, 0);
664
665 if (state == WPA_COMPLETED && wpa_s->new_connection) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700666 struct wpa_ssid *ssid = wpa_s->current_ssid;
Dmitry Shmidt700a1372013-03-15 14:14:44 -0700667#if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700668 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
Dmitry Shmidt8f0dbf42013-11-08 13:35:41 -0800669 MACSTR " completed [id=%d id_str=%s]",
Dmitry Shmidtf8623282013-02-20 14:34:59 -0800670 MAC2STR(wpa_s->bssid),
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700671 ssid ? ssid->id : -1,
672 ssid && ssid->id_str ? ssid->id_str : "");
673#endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700674 wpas_clear_temp_disabled(wpa_s, ssid, 1);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800675 wpa_s->extra_blacklist_count = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700676 wpa_s->new_connection = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700677 wpa_drv_set_operstate(wpa_s, 1);
678#ifndef IEEE8021X_EAPOL
679 wpa_drv_set_supp_port(wpa_s, 1);
680#endif /* IEEE8021X_EAPOL */
681 wpa_s->after_wps = 0;
Dmitry Shmidt68d0e3e2013-10-28 17:59:21 -0700682 wpa_s->known_wps_freq = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700683#ifdef CONFIG_P2P
684 wpas_p2p_completed(wpa_s);
685#endif /* CONFIG_P2P */
Dmitry Shmidt04949592012-07-19 12:16:46 -0700686
687 sme_sched_obss_scan(wpa_s, 1);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700688 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
689 state == WPA_ASSOCIATED) {
690 wpa_s->new_connection = 1;
691 wpa_drv_set_operstate(wpa_s, 0);
692#ifndef IEEE8021X_EAPOL
693 wpa_drv_set_supp_port(wpa_s, 0);
694#endif /* IEEE8021X_EAPOL */
Dmitry Shmidt04949592012-07-19 12:16:46 -0700695 sme_sched_obss_scan(wpa_s, 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700696 }
697 wpa_s->wpa_state = state;
698
699#ifdef CONFIG_BGSCAN
700 if (state == WPA_COMPLETED)
701 wpa_supplicant_start_bgscan(wpa_s);
702 else
703 wpa_supplicant_stop_bgscan(wpa_s);
704#endif /* CONFIG_BGSCAN */
705
Dmitry Shmidt04949592012-07-19 12:16:46 -0700706 if (state == WPA_AUTHENTICATING)
707 wpa_supplicant_stop_autoscan(wpa_s);
708
709 if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
710 wpa_supplicant_start_autoscan(wpa_s);
711
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700712 if (wpa_s->wpa_state != old_state) {
713 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
714
715 if (wpa_s->wpa_state == WPA_COMPLETED ||
716 old_state == WPA_COMPLETED)
717 wpas_notify_auth_changed(wpa_s);
718 }
719}
720
721
722void wpa_supplicant_terminate_proc(struct wpa_global *global)
723{
724 int pending = 0;
725#ifdef CONFIG_WPS
726 struct wpa_supplicant *wpa_s = global->ifaces;
727 while (wpa_s) {
Dmitry Shmidt56052862013-10-04 10:23:25 -0700728#ifdef CONFIG_P2P
729 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
730 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
731 wpas_p2p_disconnect(wpa_s);
732#endif /* CONFIG_P2P */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700733 if (wpas_wps_terminate_pending(wpa_s) == 1)
734 pending = 1;
735 wpa_s = wpa_s->next;
736 }
737#endif /* CONFIG_WPS */
738 if (pending)
739 return;
740 eloop_terminate();
741}
742
743
744static void wpa_supplicant_terminate(int sig, void *signal_ctx)
745{
746 struct wpa_global *global = signal_ctx;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700747 wpa_supplicant_terminate_proc(global);
748}
749
750
751void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
752{
753 enum wpa_states old_state = wpa_s->wpa_state;
754
755 wpa_s->pairwise_cipher = 0;
756 wpa_s->group_cipher = 0;
757 wpa_s->mgmt_group_cipher = 0;
758 wpa_s->key_mgmt = 0;
759 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
Dmitry Shmidt04949592012-07-19 12:16:46 -0700760 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700761
762 if (wpa_s->wpa_state != old_state)
763 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
764}
765
766
767/**
768 * wpa_supplicant_reload_configuration - Reload configuration data
769 * @wpa_s: Pointer to wpa_supplicant data
770 * Returns: 0 on success or -1 if configuration parsing failed
771 *
772 * This function can be used to request that the configuration data is reloaded
773 * (e.g., after configuration file change). This function is reloading
774 * configuration only for one interface, so this may need to be called multiple
775 * times if %wpa_supplicant is controlling multiple interfaces and all
776 * interfaces need reconfiguration.
777 */
778int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
779{
780 struct wpa_config *conf;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700781 int reconf_ctrl;
782 int old_ap_scan;
783
784 if (wpa_s->confname == NULL)
785 return -1;
Dmitry Shmidt64f47c52013-04-16 10:41:54 -0700786 conf = wpa_config_read(wpa_s->confname, NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700787 if (conf == NULL) {
788 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
789 "file '%s' - exiting", wpa_s->confname);
790 return -1;
791 }
Dmitry Shmidt64f47c52013-04-16 10:41:54 -0700792 wpa_config_read(wpa_s->confanother, conf);
793
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700794 conf->changed_parameters = (unsigned int) -1;
795
796 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
797 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
798 os_strcmp(conf->ctrl_interface,
799 wpa_s->conf->ctrl_interface) != 0);
800
801 if (reconf_ctrl && wpa_s->ctrl_iface) {
802 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
803 wpa_s->ctrl_iface = NULL;
804 }
805
806 eapol_sm_invalidate_cached_session(wpa_s->eapol);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800807 if (wpa_s->current_ssid) {
808 wpa_supplicant_deauthenticate(wpa_s,
809 WLAN_REASON_DEAUTH_LEAVING);
810 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700811
812 /*
813 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
814 * pkcs11_engine_path, pkcs11_module_path.
815 */
816 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
817 /*
818 * Clear forced success to clear EAP state for next
819 * authentication.
820 */
821 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
822 }
823 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
824 wpa_sm_set_config(wpa_s->wpa, NULL);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800825 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700826 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
827 rsn_preauth_deinit(wpa_s->wpa);
828
829 old_ap_scan = wpa_s->conf->ap_scan;
830 wpa_config_free(wpa_s->conf);
831 wpa_s->conf = conf;
832 if (old_ap_scan != wpa_s->conf->ap_scan)
833 wpas_notify_ap_scan_changed(wpa_s);
834
835 if (reconf_ctrl)
836 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
837
838 wpa_supplicant_update_config(wpa_s);
839
840 wpa_supplicant_clear_status(wpa_s);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700841 if (wpa_supplicant_enabled_networks(wpa_s)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700842 wpa_s->reassociate = 1;
843 wpa_supplicant_req_scan(wpa_s, 0, 0);
844 }
845 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
846 return 0;
847}
848
849
850static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
851{
852 struct wpa_global *global = signal_ctx;
853 struct wpa_supplicant *wpa_s;
854 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
855 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
856 sig);
857 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
858 wpa_supplicant_terminate_proc(global);
859 }
860 }
861}
862
863
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700864enum wpa_key_mgmt key_mgmt2driver(int key_mgmt)
865{
866 switch (key_mgmt) {
867 case WPA_KEY_MGMT_NONE:
868 return KEY_MGMT_NONE;
869 case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
870 return KEY_MGMT_802_1X_NO_WPA;
871 case WPA_KEY_MGMT_IEEE8021X:
872 return KEY_MGMT_802_1X;
873 case WPA_KEY_MGMT_WPA_NONE:
874 return KEY_MGMT_WPA_NONE;
875 case WPA_KEY_MGMT_FT_IEEE8021X:
876 return KEY_MGMT_FT_802_1X;
877 case WPA_KEY_MGMT_FT_PSK:
878 return KEY_MGMT_FT_PSK;
879 case WPA_KEY_MGMT_IEEE8021X_SHA256:
880 return KEY_MGMT_802_1X_SHA256;
881 case WPA_KEY_MGMT_PSK_SHA256:
882 return KEY_MGMT_PSK_SHA256;
883 case WPA_KEY_MGMT_WPS:
884 return KEY_MGMT_WPS;
885 case WPA_KEY_MGMT_PSK:
886 default:
887 return KEY_MGMT_PSK;
888 }
889}
890
891
892static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
893 struct wpa_ssid *ssid,
894 struct wpa_ie_data *ie)
895{
896 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
897 if (ret) {
898 if (ret == -2) {
899 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
900 "from association info");
901 }
902 return -1;
903 }
904
905 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
906 "cipher suites");
907 if (!(ie->group_cipher & ssid->group_cipher)) {
908 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
909 "cipher 0x%x (mask 0x%x) - reject",
910 ie->group_cipher, ssid->group_cipher);
911 return -1;
912 }
913 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
914 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
915 "cipher 0x%x (mask 0x%x) - reject",
916 ie->pairwise_cipher, ssid->pairwise_cipher);
917 return -1;
918 }
919 if (!(ie->key_mgmt & ssid->key_mgmt)) {
920 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
921 "management 0x%x (mask 0x%x) - reject",
922 ie->key_mgmt, ssid->key_mgmt);
923 return -1;
924 }
925
926#ifdef CONFIG_IEEE80211W
927 if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800928 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
929 wpa_s->conf->pmf : ssid->ieee80211w) ==
930 MGMT_FRAME_PROTECTION_REQUIRED) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700931 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
932 "that does not support management frame protection - "
933 "reject");
934 return -1;
935 }
936#endif /* CONFIG_IEEE80211W */
937
938 return 0;
939}
940
941
942/**
943 * wpa_supplicant_set_suites - Set authentication and encryption parameters
944 * @wpa_s: Pointer to wpa_supplicant data
945 * @bss: Scan results for the selected BSS, or %NULL if not available
946 * @ssid: Configuration data for the selected network
947 * @wpa_ie: Buffer for the WPA/RSN IE
948 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
949 * used buffer length in case the functions returns success.
950 * Returns: 0 on success or -1 on failure
951 *
952 * This function is used to configure authentication and encryption parameters
953 * based on the network configuration and scan result for the selected BSS (if
954 * available).
955 */
956int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
957 struct wpa_bss *bss, struct wpa_ssid *ssid,
958 u8 *wpa_ie, size_t *wpa_ie_len)
959{
960 struct wpa_ie_data ie;
961 int sel, proto;
962 const u8 *bss_wpa, *bss_rsn;
963
964 if (bss) {
965 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
966 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
967 } else
968 bss_wpa = bss_rsn = NULL;
969
970 if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
971 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
972 (ie.group_cipher & ssid->group_cipher) &&
973 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
974 (ie.key_mgmt & ssid->key_mgmt)) {
975 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
976 proto = WPA_PROTO_RSN;
977 } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
978 wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
979 (ie.group_cipher & ssid->group_cipher) &&
980 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
981 (ie.key_mgmt & ssid->key_mgmt)) {
982 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
983 proto = WPA_PROTO_WPA;
984 } else if (bss) {
985 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
986 return -1;
987 } else {
988 if (ssid->proto & WPA_PROTO_RSN)
989 proto = WPA_PROTO_RSN;
990 else
991 proto = WPA_PROTO_WPA;
992 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
993 os_memset(&ie, 0, sizeof(ie));
994 ie.group_cipher = ssid->group_cipher;
995 ie.pairwise_cipher = ssid->pairwise_cipher;
996 ie.key_mgmt = ssid->key_mgmt;
997#ifdef CONFIG_IEEE80211W
998 ie.mgmt_group_cipher =
999 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
1000 WPA_CIPHER_AES_128_CMAC : 0;
1001#endif /* CONFIG_IEEE80211W */
1002 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1003 "based on configuration");
1004 } else
1005 proto = ie.proto;
1006 }
1007
1008 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1009 "pairwise %d key_mgmt %d proto %d",
1010 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
1011#ifdef CONFIG_IEEE80211W
1012 if (ssid->ieee80211w) {
1013 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1014 ie.mgmt_group_cipher);
1015 }
1016#endif /* CONFIG_IEEE80211W */
1017
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001018 wpa_s->wpa_proto = proto;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001019 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1020 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1021 !!(ssid->proto & WPA_PROTO_RSN));
1022
1023 if (bss || !wpa_s->ap_ies_from_associnfo) {
1024 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1025 bss_wpa ? 2 + bss_wpa[1] : 0) ||
1026 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1027 bss_rsn ? 2 + bss_rsn[1] : 0))
1028 return -1;
1029 }
1030
1031 sel = ie.group_cipher & ssid->group_cipher;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001032 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1033 if (wpa_s->group_cipher < 0) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001034 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1035 "cipher");
1036 return -1;
1037 }
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001038 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1039 wpa_cipher_txt(wpa_s->group_cipher));
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001040
1041 sel = ie.pairwise_cipher & ssid->pairwise_cipher;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001042 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1043 if (wpa_s->pairwise_cipher < 0) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001044 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1045 "cipher");
1046 return -1;
1047 }
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001048 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1049 wpa_cipher_txt(wpa_s->pairwise_cipher));
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001050
1051 sel = ie.key_mgmt & ssid->key_mgmt;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001052#ifdef CONFIG_SAE
1053 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1054 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE);
1055#endif /* CONFIG_SAE */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001056 if (0) {
1057#ifdef CONFIG_IEEE80211R
1058 } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1059 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1060 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1061 } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1062 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1063 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1064#endif /* CONFIG_IEEE80211R */
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001065#ifdef CONFIG_SAE
1066 } else if (sel & WPA_KEY_MGMT_SAE) {
1067 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1068 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1069 } else if (sel & WPA_KEY_MGMT_FT_SAE) {
1070 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1071 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1072#endif /* CONFIG_SAE */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001073#ifdef CONFIG_IEEE80211W
1074 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1075 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1076 wpa_dbg(wpa_s, MSG_DEBUG,
1077 "WPA: using KEY_MGMT 802.1X with SHA256");
1078 } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1079 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1080 wpa_dbg(wpa_s, MSG_DEBUG,
1081 "WPA: using KEY_MGMT PSK with SHA256");
1082#endif /* CONFIG_IEEE80211W */
1083 } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1084 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1085 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1086 } else if (sel & WPA_KEY_MGMT_PSK) {
1087 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1088 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1089 } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1090 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1091 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1092 } else {
1093 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1094 "authenticated key management type");
1095 return -1;
1096 }
1097
1098 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1099 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1100 wpa_s->pairwise_cipher);
1101 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1102
1103#ifdef CONFIG_IEEE80211W
1104 sel = ie.mgmt_group_cipher;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001105 if ((ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1106 wpa_s->conf->pmf : ssid->ieee80211w) == NO_MGMT_FRAME_PROTECTION ||
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001107 !(ie.capabilities & WPA_CAPABILITY_MFPC))
1108 sel = 0;
1109 if (sel & WPA_CIPHER_AES_128_CMAC) {
1110 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1111 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1112 "AES-128-CMAC");
1113 } else {
1114 wpa_s->mgmt_group_cipher = 0;
1115 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1116 }
1117 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1118 wpa_s->mgmt_group_cipher);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001119 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1120 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1121 wpa_s->conf->pmf : ssid->ieee80211w));
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001122#endif /* CONFIG_IEEE80211W */
1123
1124 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1125 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1126 return -1;
1127 }
1128
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001129 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001130 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001131#ifndef CONFIG_NO_PBKDF2
1132 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1133 ssid->passphrase) {
1134 u8 psk[PMK_LEN];
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001135 pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len,
1136 4096, psk, PMK_LEN);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001137 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1138 psk, PMK_LEN);
1139 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1140 }
1141#endif /* CONFIG_NO_PBKDF2 */
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001142#ifdef CONFIG_EXT_PASSWORD
1143 if (ssid->ext_psk) {
1144 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1145 ssid->ext_psk);
1146 char pw_str[64 + 1];
1147 u8 psk[PMK_LEN];
1148
1149 if (pw == NULL) {
1150 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1151 "found from external storage");
1152 return -1;
1153 }
1154
1155 if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) {
1156 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1157 "PSK length %d in external storage",
1158 (int) wpabuf_len(pw));
1159 ext_password_free(pw);
1160 return -1;
1161 }
1162
1163 os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw));
1164 pw_str[wpabuf_len(pw)] = '\0';
1165
1166#ifndef CONFIG_NO_PBKDF2
1167 if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss)
1168 {
1169 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len,
1170 4096, psk, PMK_LEN);
1171 os_memset(pw_str, 0, sizeof(pw_str));
1172 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from "
1173 "external passphrase)",
1174 psk, PMK_LEN);
1175 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1176 } else
1177#endif /* CONFIG_NO_PBKDF2 */
1178 if (wpabuf_len(pw) == 2 * PMK_LEN) {
1179 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) {
1180 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1181 "Invalid PSK hex string");
1182 os_memset(pw_str, 0, sizeof(pw_str));
1183 ext_password_free(pw);
1184 return -1;
1185 }
1186 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1187 } else {
1188 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1189 "PSK available");
1190 os_memset(pw_str, 0, sizeof(pw_str));
1191 ext_password_free(pw);
1192 return -1;
1193 }
1194
1195 os_memset(pw_str, 0, sizeof(pw_str));
1196 ext_password_free(pw);
1197 }
1198#endif /* CONFIG_EXT_PASSWORD */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001199 } else
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001200 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1201
1202 return 0;
1203}
1204
1205
Dmitry Shmidt444d5672013-04-01 13:08:44 -07001206static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1207{
1208 *pos = 0x00;
1209
1210 switch (idx) {
1211 case 0: /* Bits 0-7 */
1212 break;
1213 case 1: /* Bits 8-15 */
1214 break;
1215 case 2: /* Bits 16-23 */
1216#ifdef CONFIG_WNM
1217 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */
1218 *pos |= 0x08; /* Bit 19 - BSS Transition */
1219#endif /* CONFIG_WNM */
1220 break;
1221 case 3: /* Bits 24-31 */
1222#ifdef CONFIG_WNM
1223 *pos |= 0x02; /* Bit 25 - SSID List */
1224#endif /* CONFIG_WNM */
1225#ifdef CONFIG_INTERWORKING
1226 if (wpa_s->conf->interworking)
1227 *pos |= 0x80; /* Bit 31 - Interworking */
1228#endif /* CONFIG_INTERWORKING */
1229 break;
1230 case 4: /* Bits 32-39 */
Dmitry Shmidt051af732013-10-22 13:52:46 -07001231#ifdef CONFIG_INTERWORKING
1232 *pos |= 0x01; /* Bit 32 - QoS Map */
1233#endif /* CONFIG_INTERWORKING */
Dmitry Shmidt444d5672013-04-01 13:08:44 -07001234 break;
1235 case 5: /* Bits 40-47 */
1236 break;
1237 case 6: /* Bits 48-55 */
1238 break;
1239 }
1240}
1241
1242
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001243int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf)
1244{
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001245 u8 *pos = buf;
Dmitry Shmidt444d5672013-04-01 13:08:44 -07001246 u8 len = 4, i;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001247
Dmitry Shmidt444d5672013-04-01 13:08:44 -07001248 if (len < wpa_s->extended_capa_len)
1249 len = wpa_s->extended_capa_len;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001250
1251 *pos++ = WLAN_EID_EXT_CAPAB;
Dmitry Shmidt444d5672013-04-01 13:08:44 -07001252 *pos++ = len;
1253 for (i = 0; i < len; i++, pos++) {
1254 wpas_ext_capab_byte(wpa_s, pos, i);
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001255
Dmitry Shmidt444d5672013-04-01 13:08:44 -07001256 if (i < wpa_s->extended_capa_len) {
1257 *pos &= ~wpa_s->extended_capa_mask[i];
1258 *pos |= wpa_s->extended_capa[i];
1259 }
1260 }
1261
1262 while (len > 0 && buf[1 + len] == 0) {
1263 len--;
1264 buf[1] = len;
1265 }
1266 if (len == 0)
1267 return 0;
1268
1269 return 2 + len;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001270}
1271
1272
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001273/**
1274 * wpa_supplicant_associate - Request association
1275 * @wpa_s: Pointer to wpa_supplicant data
1276 * @bss: Scan results for the selected BSS, or %NULL if not available
1277 * @ssid: Configuration data for the selected network
1278 *
1279 * This function is used to request %wpa_supplicant to associate with a BSS.
1280 */
1281void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1282 struct wpa_bss *bss, struct wpa_ssid *ssid)
1283{
1284 u8 wpa_ie[200];
1285 size_t wpa_ie_len;
1286 int use_crypt, ret, i, bssid_changed;
1287 int algs = WPA_AUTH_ALG_OPEN;
1288 enum wpa_cipher cipher_pairwise, cipher_group;
1289 struct wpa_driver_associate_params params;
1290 int wep_keys_set = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001291 int assoc_failed = 0;
1292 struct wpa_ssid *old_ssid;
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001293#ifdef CONFIG_HT_OVERRIDES
1294 struct ieee80211_ht_capabilities htcaps;
1295 struct ieee80211_ht_capabilities htcaps_mask;
1296#endif /* CONFIG_HT_OVERRIDES */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001297
1298#ifdef CONFIG_IBSS_RSN
1299 ibss_rsn_deinit(wpa_s->ibss_rsn);
1300 wpa_s->ibss_rsn = NULL;
1301#endif /* CONFIG_IBSS_RSN */
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001302#ifdef ANDROID_P2P
1303 int freq = 0;
1304#endif
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001305
1306 if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1307 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1308#ifdef CONFIG_AP
1309 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1310 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1311 "mode");
1312 return;
1313 }
Dmitry Shmidtaa532512012-09-24 10:35:31 -07001314 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1315 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07001316 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
1317 wpas_p2p_ap_setup_failed(wpa_s);
Dmitry Shmidtaa532512012-09-24 10:35:31 -07001318 return;
1319 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001320 wpa_s->current_bss = bss;
1321#else /* CONFIG_AP */
1322 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1323 "the build");
1324#endif /* CONFIG_AP */
1325 return;
1326 }
1327
1328#ifdef CONFIG_TDLS
1329 if (bss)
1330 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1331 bss->ie_len);
1332#endif /* CONFIG_TDLS */
1333
1334 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1335 ssid->mode == IEEE80211_MODE_INFRA) {
1336 sme_authenticate(wpa_s, bss, ssid);
1337 return;
1338 }
1339
1340 os_memset(&params, 0, sizeof(params));
1341 wpa_s->reassociate = 0;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001342 if (bss && !wpas_driver_bss_selection(wpa_s)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001343#ifdef CONFIG_IEEE80211R
1344 const u8 *ie, *md = NULL;
1345#endif /* CONFIG_IEEE80211R */
1346 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1347 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
1348 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
1349 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1350 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1351 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1352 if (bssid_changed)
1353 wpas_notify_bssid_changed(wpa_s);
1354#ifdef CONFIG_IEEE80211R
1355 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
1356 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1357 md = ie + 2;
1358 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1359 if (md) {
1360 /* Prepare for the next transition */
1361 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1362 }
1363#endif /* CONFIG_IEEE80211R */
1364#ifdef CONFIG_WPS
1365 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1366 wpa_s->conf->ap_scan == 2 &&
1367 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1368 /* Use ap_scan==1 style network selection to find the network
1369 */
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001370 wpa_s->scan_req = MANUAL_SCAN_REQ;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001371 wpa_s->reassociate = 1;
1372 wpa_supplicant_req_scan(wpa_s, 0, 0);
1373 return;
1374#endif /* CONFIG_WPS */
1375 } else {
1376 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1377 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1378 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1379 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001380 wpa_supplicant_cancel_sched_scan(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001381 wpa_supplicant_cancel_scan(wpa_s);
1382
1383 /* Starting new association, so clear the possibly used WPA IE from the
1384 * previous association. */
1385 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1386
1387#ifdef IEEE8021X_EAPOL
1388 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1389 if (ssid->leap) {
1390 if (ssid->non_leap == 0)
1391 algs = WPA_AUTH_ALG_LEAP;
1392 else
1393 algs |= WPA_AUTH_ALG_LEAP;
1394 }
1395 }
1396#endif /* IEEE8021X_EAPOL */
1397 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1398 if (ssid->auth_alg) {
1399 algs = ssid->auth_alg;
1400 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1401 "0x%x", algs);
1402 }
1403
1404 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1405 wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001406 wpa_key_mgmt_wpa(ssid->key_mgmt)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001407 int try_opportunistic;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001408 try_opportunistic = (ssid->proactive_key_caching < 0 ?
1409 wpa_s->conf->okc :
1410 ssid->proactive_key_caching) &&
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001411 (ssid->proto & WPA_PROTO_RSN);
1412 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
Dmitry Shmidt700a1372013-03-15 14:14:44 -07001413 ssid, try_opportunistic) == 0)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001414 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1415 wpa_ie_len = sizeof(wpa_ie);
1416 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1417 wpa_ie, &wpa_ie_len)) {
1418 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1419 "key management and encryption suites");
1420 return;
1421 }
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001422 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
1423 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
1424 /*
1425 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
1426 * use non-WPA since the scan results did not indicate that the
1427 * AP is using WPA or WPA2.
1428 */
1429 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1430 wpa_ie_len = 0;
1431 wpa_s->wpa_proto = 0;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001432 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001433 wpa_ie_len = sizeof(wpa_ie);
1434 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1435 wpa_ie, &wpa_ie_len)) {
1436 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1437 "key management and encryption suites (no "
1438 "scan results)");
1439 return;
1440 }
1441#ifdef CONFIG_WPS
1442 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
1443 struct wpabuf *wps_ie;
1444 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
1445 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1446 wpa_ie_len = wpabuf_len(wps_ie);
1447 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
1448 } else
1449 wpa_ie_len = 0;
1450 wpabuf_free(wps_ie);
1451 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1452 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1453 params.wps = WPS_MODE_PRIVACY;
1454 else
1455 params.wps = WPS_MODE_OPEN;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001456 wpa_s->wpa_proto = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001457#endif /* CONFIG_WPS */
1458 } else {
1459 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1460 wpa_ie_len = 0;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001461 wpa_s->wpa_proto = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001462 }
1463
1464#ifdef CONFIG_P2P
1465 if (wpa_s->global->p2p) {
1466 u8 *pos;
1467 size_t len;
1468 int res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001469 pos = wpa_ie + wpa_ie_len;
1470 len = sizeof(wpa_ie) - wpa_ie_len;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001471 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1472 ssid->p2p_group);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001473 if (res >= 0)
1474 wpa_ie_len += res;
1475 }
1476
1477 wpa_s->cross_connect_disallowed = 0;
1478 if (bss) {
1479 struct wpabuf *p2p;
1480 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1481 if (p2p) {
1482 wpa_s->cross_connect_disallowed =
1483 p2p_get_cross_connect_disallowed(p2p);
1484 wpabuf_free(p2p);
1485 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1486 "connection",
1487 wpa_s->cross_connect_disallowed ?
1488 "disallows" : "allows");
1489 }
1490 }
1491#endif /* CONFIG_P2P */
1492
Dmitry Shmidt04949592012-07-19 12:16:46 -07001493#ifdef CONFIG_HS20
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -07001494 if (is_hs20_network(wpa_s, ssid, bss)) {
Dmitry Shmidt04949592012-07-19 12:16:46 -07001495 struct wpabuf *hs20;
1496 hs20 = wpabuf_alloc(20);
1497 if (hs20) {
1498 wpas_hs20_add_indication(hs20);
1499 os_memcpy(wpa_ie + wpa_ie_len, wpabuf_head(hs20),
1500 wpabuf_len(hs20));
1501 wpa_ie_len += wpabuf_len(hs20);
1502 wpabuf_free(hs20);
1503 }
1504 }
1505#endif /* CONFIG_HS20 */
1506
Dmitry Shmidt56052862013-10-04 10:23:25 -07001507 /*
1508 * Workaround: Add Extended Capabilities element only if the AP
1509 * included this element in Beacon/Probe Response frames. Some older
1510 * APs seem to have interoperability issues if this element is
1511 * included, so while the standard may require us to include the
1512 * element in all cases, it is justifiable to skip it to avoid
1513 * interoperability issues.
1514 */
1515 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
1516 u8 ext_capab[10];
1517 int ext_capab_len;
1518 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab);
1519 if (ext_capab_len > 0) {
1520 u8 *pos = wpa_ie;
1521 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
1522 pos += 2 + pos[1];
1523 os_memmove(pos + ext_capab_len, pos,
1524 wpa_ie_len - (pos - wpa_ie));
1525 wpa_ie_len += ext_capab_len;
1526 os_memcpy(pos, ext_capab, ext_capab_len);
1527 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001528 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001529
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001530 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1531 use_crypt = 1;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08001532 cipher_pairwise = wpa_cipher_to_suite_driver(wpa_s->pairwise_cipher);
1533 cipher_group = wpa_cipher_to_suite_driver(wpa_s->group_cipher);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001534 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1535 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1536 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1537 use_crypt = 0;
1538 if (wpa_set_wep_keys(wpa_s, ssid)) {
1539 use_crypt = 1;
1540 wep_keys_set = 1;
1541 }
1542 }
1543 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1544 use_crypt = 0;
1545
1546#ifdef IEEE8021X_EAPOL
1547 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1548 if ((ssid->eapol_flags &
1549 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1550 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1551 !wep_keys_set) {
1552 use_crypt = 0;
1553 } else {
1554 /* Assume that dynamic WEP-104 keys will be used and
1555 * set cipher suites in order for drivers to expect
1556 * encryption. */
1557 cipher_pairwise = cipher_group = CIPHER_WEP104;
1558 }
1559 }
1560#endif /* IEEE8021X_EAPOL */
1561
1562 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1563 /* Set the key before (and later after) association */
1564 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1565 }
1566
1567 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1568 if (bss) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001569 params.ssid = bss->ssid;
1570 params.ssid_len = bss->ssid_len;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001571 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1572 wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
1573 MACSTR " freq=%u MHz based on scan results "
1574 "(bssid_set=%d)",
1575 MAC2STR(bss->bssid), bss->freq,
1576 ssid->bssid_set);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001577 params.bssid = bss->bssid;
1578 params.freq = bss->freq;
1579 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001580 } else {
1581 params.ssid = ssid->ssid;
1582 params.ssid_len = ssid->ssid_len;
1583 }
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001584
1585 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
1586 wpa_s->conf->ap_scan == 2) {
1587 params.bssid = ssid->bssid;
1588 params.fixed_bssid = 1;
1589 }
1590
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001591 if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
1592 params.freq == 0)
1593 params.freq = ssid->frequency; /* Initial channel for IBSS */
1594 params.wpa_ie = wpa_ie;
1595 params.wpa_ie_len = wpa_ie_len;
1596 params.pairwise_suite = cipher_pairwise;
1597 params.group_suite = cipher_group;
1598 params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001599 params.wpa_proto = wpa_s->wpa_proto;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001600 params.auth_alg = algs;
1601 params.mode = ssid->mode;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001602 params.bg_scan_period = ssid->bg_scan_period;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001603 for (i = 0; i < NUM_WEP_KEYS; i++) {
1604 if (ssid->wep_key_len[i])
1605 params.wep_key[i] = ssid->wep_key[i];
1606 params.wep_key_len[i] = ssid->wep_key_len[i];
1607 }
1608 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1609
1610 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1611 (params.key_mgmt_suite == KEY_MGMT_PSK ||
1612 params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1613 params.passphrase = ssid->passphrase;
1614 if (ssid->psk_set)
1615 params.psk = ssid->psk;
1616 }
1617
1618 params.drop_unencrypted = use_crypt;
1619
1620#ifdef CONFIG_IEEE80211W
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001621 params.mgmt_frame_protection =
1622 ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1623 wpa_s->conf->pmf : ssid->ieee80211w;
1624 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001625 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1626 struct wpa_ie_data ie;
1627 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1628 ie.capabilities &
1629 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1630 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1631 "MFP: require MFP");
1632 params.mgmt_frame_protection =
1633 MGMT_FRAME_PROTECTION_REQUIRED;
1634 }
1635 }
1636#endif /* CONFIG_IEEE80211W */
1637
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001638 params.p2p = ssid->p2p_group;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001639
1640 if (wpa_s->parent->set_sta_uapsd)
1641 params.uapsd = wpa_s->parent->sta_uapsd;
1642 else
1643 params.uapsd = -1;
1644
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001645#ifdef CONFIG_HT_OVERRIDES
1646 os_memset(&htcaps, 0, sizeof(htcaps));
1647 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
1648 params.htcaps = (u8 *) &htcaps;
1649 params.htcaps_mask = (u8 *) &htcaps_mask;
1650 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
1651#endif /* CONFIG_HT_OVERRIDES */
1652
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001653#ifdef ANDROID_P2P
1654 /* If multichannel concurrency is not supported, check for any frequency
1655 * conflict and take appropriate action.
1656 */
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07001657 if ((wpa_s->num_multichan_concurrent < 2) &&
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001658 ((freq = wpa_drv_shared_freq(wpa_s)) > 0) && (freq != params.freq)) {
1659 wpa_printf(MSG_DEBUG, "Shared interface with conflicting frequency found (%d != %d)"
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001660 , freq, params.freq);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001661 if (wpas_p2p_handle_frequency_conflicts(wpa_s, params.freq, ssid) < 0)
Dmitry Shmidt687922c2012-03-26 14:02:32 -07001662 return;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001663 }
1664#endif
1665 ret = wpa_drv_associate(wpa_s, &params);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001666 if (ret < 0) {
1667 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1668 "failed");
1669 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1670 /*
1671 * The driver is known to mean what is saying, so we
1672 * can stop right here; the association will not
1673 * succeed.
1674 */
1675 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
Dmitry Shmidt04949592012-07-19 12:16:46 -07001676 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001677 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1678 return;
1679 }
1680 /* try to continue anyway; new association will be tried again
1681 * after timeout */
1682 assoc_failed = 1;
1683 }
1684
1685 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1686 /* Set the key after the association just in case association
1687 * cleared the previously configured key. */
1688 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1689 /* No need to timeout authentication since there is no key
1690 * management. */
1691 wpa_supplicant_cancel_auth_timeout(wpa_s);
1692 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1693#ifdef CONFIG_IBSS_RSN
1694 } else if (ssid->mode == WPAS_MODE_IBSS &&
1695 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1696 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1697 /*
1698 * RSN IBSS authentication is per-STA and we can disable the
1699 * per-BSSID authentication.
1700 */
1701 wpa_supplicant_cancel_auth_timeout(wpa_s);
1702#endif /* CONFIG_IBSS_RSN */
1703 } else {
1704 /* Timeout for IEEE 802.11 authentication and association */
1705 int timeout = 60;
1706
1707 if (assoc_failed) {
1708 /* give IBSS a bit more time */
1709 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
1710 } else if (wpa_s->conf->ap_scan == 1) {
1711 /* give IBSS a bit more time */
1712 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
1713 }
1714 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1715 }
1716
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -07001717 if (wep_keys_set &&
1718 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001719 /* Set static WEP keys again */
1720 wpa_set_wep_keys(wpa_s, ssid);
1721 }
1722
1723 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1724 /*
1725 * Do not allow EAP session resumption between different
1726 * network configurations.
1727 */
1728 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1729 }
1730 old_ssid = wpa_s->current_ssid;
1731 wpa_s->current_ssid = ssid;
1732 wpa_s->current_bss = bss;
1733 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1734 wpa_supplicant_initiate_eapol(wpa_s);
1735 if (old_ssid != wpa_s->current_ssid)
1736 wpas_notify_network_changed(wpa_s);
1737}
1738
1739
1740static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1741 const u8 *addr)
1742{
1743 struct wpa_ssid *old_ssid;
1744
1745 wpa_clear_keys(wpa_s, addr);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001746 old_ssid = wpa_s->current_ssid;
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001747 wpa_supplicant_mark_disassoc(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001748 wpa_sm_set_config(wpa_s->wpa, NULL);
1749 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1750 if (old_ssid != wpa_s->current_ssid)
1751 wpas_notify_network_changed(wpa_s);
1752 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1753}
1754
1755
1756/**
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001757 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1758 * @wpa_s: Pointer to wpa_supplicant data
1759 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1760 *
1761 * This function is used to request %wpa_supplicant to deauthenticate from the
1762 * current AP.
1763 */
1764void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1765 int reason_code)
1766{
1767 u8 *addr = NULL;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001768 union wpa_event_data event;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001769 int zero_addr = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001770
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001771 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
1772 " pending_bssid=" MACSTR " reason=%d state=%s",
1773 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
1774 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
1775
1776 if (!is_zero_ether_addr(wpa_s->bssid))
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001777 addr = wpa_s->bssid;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001778 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
1779 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
1780 wpa_s->wpa_state == WPA_ASSOCIATING))
1781 addr = wpa_s->pending_bssid;
1782 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
1783 /*
1784 * When using driver-based BSS selection, we may not know the
1785 * BSSID with which we are currently trying to associate. We
1786 * need to notify the driver of this disconnection even in such
1787 * a case, so use the all zeros address here.
1788 */
1789 addr = wpa_s->bssid;
1790 zero_addr = 1;
1791 }
1792
Dmitry Shmidtf8623282013-02-20 14:34:59 -08001793#ifdef CONFIG_TDLS
1794 wpa_tdls_teardown_peers(wpa_s->wpa);
1795#endif /* CONFIG_TDLS */
1796
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001797 if (addr) {
1798 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
Dmitry Shmidt04949592012-07-19 12:16:46 -07001799 os_memset(&event, 0, sizeof(event));
1800 event.deauth_info.reason_code = (u16) reason_code;
1801 event.deauth_info.locally_generated = 1;
1802 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001803 if (zero_addr)
1804 addr = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001805 }
1806
1807 wpa_supplicant_clear_connection(wpa_s, addr);
1808}
1809
Dmitry Shmidt2f023192013-03-12 12:44:17 -07001810static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
1811 struct wpa_ssid *ssid)
1812{
1813 if (!ssid || !ssid->disabled || ssid->disabled == 2)
1814 return;
1815
1816 ssid->disabled = 0;
1817 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1818 wpas_notify_network_enabled_changed(wpa_s, ssid);
1819
1820 /*
1821 * Try to reassociate since there is no current configuration and a new
1822 * network was made available.
1823 */
Dmitry Shmidt4ce9c872013-10-24 11:08:13 -07001824 if (!wpa_s->current_ssid && !wpa_s->disconnected)
Dmitry Shmidt2f023192013-03-12 12:44:17 -07001825 wpa_s->reassociate = 1;
1826}
1827
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001828
1829/**
1830 * wpa_supplicant_enable_network - Mark a configured network as enabled
1831 * @wpa_s: wpa_supplicant structure for a network interface
1832 * @ssid: wpa_ssid structure for a configured network or %NULL
1833 *
1834 * Enables the specified network or all networks if no network specified.
1835 */
1836void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
1837 struct wpa_ssid *ssid)
1838{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001839 if (ssid == NULL) {
Dmitry Shmidt2f023192013-03-12 12:44:17 -07001840 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
1841 wpa_supplicant_enable_one_network(wpa_s, ssid);
1842 } else
1843 wpa_supplicant_enable_one_network(wpa_s, ssid);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001844
Dmitry Shmidt4ce9c872013-10-24 11:08:13 -07001845 if (wpa_s->reassociate && !wpa_s->disconnected) {
Dmitry Shmidt2f023192013-03-12 12:44:17 -07001846 if (wpa_s->sched_scanning) {
1847 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
1848 "new network to scan filters");
1849 wpa_supplicant_cancel_sched_scan(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001850 }
1851
Dmitry Shmidtf7e0a992013-05-23 11:03:10 -07001852 if (wpa_supplicant_fast_associate(wpa_s) != 1)
1853 wpa_supplicant_req_scan(wpa_s, 0, 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001854 }
1855}
1856
1857
1858/**
1859 * wpa_supplicant_disable_network - Mark a configured network as disabled
1860 * @wpa_s: wpa_supplicant structure for a network interface
1861 * @ssid: wpa_ssid structure for a configured network or %NULL
1862 *
1863 * Disables the specified network or all networks if no network specified.
1864 */
1865void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
1866 struct wpa_ssid *ssid)
1867{
1868 struct wpa_ssid *other_ssid;
1869 int was_disabled;
1870
1871 if (ssid == NULL) {
Dmitry Shmidt2f023192013-03-12 12:44:17 -07001872 if (wpa_s->sched_scanning)
1873 wpa_supplicant_cancel_sched_scan(wpa_s);
1874
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001875 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1876 other_ssid = other_ssid->next) {
1877 was_disabled = other_ssid->disabled;
1878 if (was_disabled == 2)
1879 continue; /* do not change persistent P2P group
1880 * data */
1881
1882 other_ssid->disabled = 1;
1883
1884 if (was_disabled != other_ssid->disabled)
1885 wpas_notify_network_enabled_changed(
1886 wpa_s, other_ssid);
1887 }
1888 if (wpa_s->current_ssid)
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001889 wpa_supplicant_deauthenticate(
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001890 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1891 } else if (ssid->disabled != 2) {
1892 if (ssid == wpa_s->current_ssid)
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001893 wpa_supplicant_deauthenticate(
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001894 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1895
1896 was_disabled = ssid->disabled;
1897
1898 ssid->disabled = 1;
1899
Dmitry Shmidt2f023192013-03-12 12:44:17 -07001900 if (was_disabled != ssid->disabled) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001901 wpas_notify_network_enabled_changed(wpa_s, ssid);
Dmitry Shmidt2f023192013-03-12 12:44:17 -07001902 if (wpa_s->sched_scanning) {
1903 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
1904 "to remove network from filters");
1905 wpa_supplicant_cancel_sched_scan(wpa_s);
1906 wpa_supplicant_req_scan(wpa_s, 0, 0);
1907 }
1908 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001909 }
1910}
1911
1912
1913/**
1914 * wpa_supplicant_select_network - Attempt association with a network
1915 * @wpa_s: wpa_supplicant structure for a network interface
1916 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
1917 */
1918void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
1919 struct wpa_ssid *ssid)
1920{
1921
1922 struct wpa_ssid *other_ssid;
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001923 int disconnected = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001924
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001925 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001926 wpa_supplicant_deauthenticate(
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001927 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001928 disconnected = 1;
1929 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001930
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001931 if (ssid)
1932 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1933
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001934 /*
1935 * Mark all other networks disabled or mark all networks enabled if no
1936 * network specified.
1937 */
1938 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1939 other_ssid = other_ssid->next) {
1940 int was_disabled = other_ssid->disabled;
1941 if (was_disabled == 2)
1942 continue; /* do not change persistent P2P group data */
1943
1944 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001945 if (was_disabled && !other_ssid->disabled)
1946 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001947
1948 if (was_disabled != other_ssid->disabled)
1949 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
1950 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001951
1952 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
1953 /* We are already associated with the selected network */
1954 wpa_printf(MSG_DEBUG, "Already associated with the "
1955 "selected network - do nothing");
1956 return;
1957 }
1958
Dmitry Shmidtb7b4d0e2013-08-26 12:09:05 -07001959 if (ssid) {
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08001960 wpa_s->current_ssid = ssid;
Dmitry Shmidtb7b4d0e2013-08-26 12:09:05 -07001961 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1962 }
Jouni Malinen75ecf522011-06-27 15:19:46 -07001963 wpa_s->connect_without_scan = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001964 wpa_s->disconnected = 0;
1965 wpa_s->reassociate = 1;
Dmitry Shmidt4b9d52f2013-02-05 17:44:43 -08001966
1967 if (wpa_supplicant_fast_associate(wpa_s) != 1)
1968 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001969
1970 if (ssid)
1971 wpas_notify_network_selected(wpa_s, ssid);
1972}
1973
1974
1975/**
Dmitry Shmidt01904cf2013-12-05 11:08:35 -08001976 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
1977 * @wpa_s: wpa_supplicant structure for a network interface
1978 * @pkcs11_engine_path: PKCS #11 engine path or NULL
1979 * @pkcs11_module_path: PKCS #11 module path or NULL
1980 * Returns: 0 on success; -1 on failure
1981 *
1982 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
1983 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
1984 * module path fails the paths will be reset to the default value (NULL).
1985 */
1986int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
1987 const char *pkcs11_engine_path,
1988 const char *pkcs11_module_path)
1989{
1990 char *pkcs11_engine_path_copy = NULL;
1991 char *pkcs11_module_path_copy = NULL;
1992
1993 if (pkcs11_engine_path != NULL) {
1994 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
1995 if (pkcs11_engine_path_copy == NULL)
1996 return -1;
1997 }
1998 if (pkcs11_module_path != NULL) {
1999 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
2000 if (pkcs11_engine_path_copy == NULL) {
2001 os_free(pkcs11_engine_path_copy);
2002 return -1;
2003 }
2004 }
2005
2006 os_free(wpa_s->conf->pkcs11_engine_path);
2007 os_free(wpa_s->conf->pkcs11_module_path);
2008 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2009 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2010
2011 wpa_sm_set_eapol(wpa_s->wpa, NULL);
2012 eapol_sm_deinit(wpa_s->eapol);
2013 wpa_s->eapol = NULL;
2014 if (wpa_supplicant_init_eapol(wpa_s)) {
2015 /* Error -> Reset paths to the default value (NULL) once. */
2016 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
2017 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2018 NULL);
2019
2020 return -1;
2021 }
2022 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2023
2024 return 0;
2025}
2026
2027
2028/**
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002029 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
2030 * @wpa_s: wpa_supplicant structure for a network interface
2031 * @ap_scan: AP scan mode
2032 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
2033 *
2034 */
2035int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
2036{
2037
2038 int old_ap_scan;
2039
2040 if (ap_scan < 0 || ap_scan > 2)
2041 return -1;
2042
Dmitry Shmidt114c3862011-08-16 11:52:06 -07002043#ifdef ANDROID
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002044 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2045 wpa_s->wpa_state >= WPA_ASSOCIATING &&
2046 wpa_s->wpa_state < WPA_COMPLETED) {
2047 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
2048 "associating", wpa_s->conf->ap_scan, ap_scan);
Dmitry Shmidt114c3862011-08-16 11:52:06 -07002049 return 0;
2050 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002051#endif /* ANDROID */
Dmitry Shmidt114c3862011-08-16 11:52:06 -07002052
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002053 old_ap_scan = wpa_s->conf->ap_scan;
2054 wpa_s->conf->ap_scan = ap_scan;
2055
2056 if (old_ap_scan != wpa_s->conf->ap_scan)
2057 wpas_notify_ap_scan_changed(wpa_s);
2058
2059 return 0;
2060}
2061
2062
2063/**
2064 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
2065 * @wpa_s: wpa_supplicant structure for a network interface
2066 * @expire_age: Expiration age in seconds
2067 * Returns: 0 if succeed or -1 if expire_age has an invalid value
2068 *
2069 */
2070int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2071 unsigned int bss_expire_age)
2072{
2073 if (bss_expire_age < 10) {
2074 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2075 bss_expire_age);
2076 return -1;
2077 }
2078 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2079 bss_expire_age);
2080 wpa_s->conf->bss_expiration_age = bss_expire_age;
2081
2082 return 0;
2083}
2084
2085
2086/**
2087 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
2088 * @wpa_s: wpa_supplicant structure for a network interface
2089 * @expire_count: number of scans after which an unseen BSS is reclaimed
2090 * Returns: 0 if succeed or -1 if expire_count has an invalid value
2091 *
2092 */
2093int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2094 unsigned int bss_expire_count)
2095{
2096 if (bss_expire_count < 1) {
2097 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2098 bss_expire_count);
2099 return -1;
2100 }
2101 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2102 bss_expire_count);
2103 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2104
2105 return 0;
2106}
2107
2108
2109/**
Dmitry Shmidt04949592012-07-19 12:16:46 -07002110 * wpa_supplicant_set_scan_interval - Set scan interval
2111 * @wpa_s: wpa_supplicant structure for a network interface
2112 * @scan_interval: scan interval in seconds
2113 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2114 *
2115 */
2116int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2117 int scan_interval)
2118{
2119 if (scan_interval < 0) {
2120 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2121 scan_interval);
2122 return -1;
2123 }
2124 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2125 scan_interval);
Dmitry Shmidt4b9d52f2013-02-05 17:44:43 -08002126 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
Dmitry Shmidt04949592012-07-19 12:16:46 -07002127
2128 return 0;
2129}
2130
2131
2132/**
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002133 * wpa_supplicant_set_debug_params - Set global debug params
2134 * @global: wpa_global structure
2135 * @debug_level: debug level
2136 * @debug_timestamp: determines if show timestamp in debug data
2137 * @debug_show_keys: determines if show keys in debug data
2138 * Returns: 0 if succeed or -1 if debug_level has wrong value
2139 */
2140int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
2141 int debug_timestamp, int debug_show_keys)
2142{
2143
2144 int old_level, old_timestamp, old_show_keys;
2145
2146 /* check for allowed debuglevels */
2147 if (debug_level != MSG_EXCESSIVE &&
2148 debug_level != MSG_MSGDUMP &&
2149 debug_level != MSG_DEBUG &&
2150 debug_level != MSG_INFO &&
2151 debug_level != MSG_WARNING &&
2152 debug_level != MSG_ERROR)
2153 return -1;
2154
2155 old_level = wpa_debug_level;
2156 old_timestamp = wpa_debug_timestamp;
2157 old_show_keys = wpa_debug_show_keys;
2158
2159 wpa_debug_level = debug_level;
2160 wpa_debug_timestamp = debug_timestamp ? 1 : 0;
2161 wpa_debug_show_keys = debug_show_keys ? 1 : 0;
2162
2163 if (wpa_debug_level != old_level)
2164 wpas_notify_debug_level_changed(global);
2165 if (wpa_debug_timestamp != old_timestamp)
2166 wpas_notify_debug_timestamp_changed(global);
2167 if (wpa_debug_show_keys != old_show_keys)
2168 wpas_notify_debug_show_keys_changed(global);
2169
2170 return 0;
2171}
2172
2173
2174/**
2175 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2176 * @wpa_s: Pointer to wpa_supplicant data
2177 * Returns: A pointer to the current network structure or %NULL on failure
2178 */
2179struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2180{
2181 struct wpa_ssid *entry;
2182 u8 ssid[MAX_SSID_LEN];
2183 int res;
2184 size_t ssid_len;
2185 u8 bssid[ETH_ALEN];
2186 int wired;
2187
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002188 res = wpa_drv_get_ssid(wpa_s, ssid);
2189 if (res < 0) {
2190 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2191 "driver");
2192 return NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002193 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002194 ssid_len = res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002195
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002196 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002197 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2198 "driver");
2199 return NULL;
2200 }
2201
2202 wired = wpa_s->conf->ap_scan == 0 &&
2203 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2204
2205 entry = wpa_s->conf->ssid;
2206 while (entry) {
Dmitry Shmidt04949592012-07-19 12:16:46 -07002207 if (!wpas_network_disabled(wpa_s, entry) &&
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002208 ((ssid_len == entry->ssid_len &&
2209 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
2210 (!entry->bssid_set ||
2211 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2212 return entry;
2213#ifdef CONFIG_WPS
Dmitry Shmidt04949592012-07-19 12:16:46 -07002214 if (!wpas_network_disabled(wpa_s, entry) &&
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002215 (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
2216 (entry->ssid == NULL || entry->ssid_len == 0) &&
2217 (!entry->bssid_set ||
2218 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2219 return entry;
2220#endif /* CONFIG_WPS */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002221
Dmitry Shmidt04949592012-07-19 12:16:46 -07002222 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002223 entry->ssid_len == 0 &&
2224 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
2225 return entry;
2226
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002227 entry = entry->next;
2228 }
2229
2230 return NULL;
2231}
2232
2233
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002234static int select_driver(struct wpa_supplicant *wpa_s, int i)
2235{
2236 struct wpa_global *global = wpa_s->global;
2237
2238 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
2239 global->drv_priv[i] = wpa_drivers[i]->global_init();
2240 if (global->drv_priv[i] == NULL) {
2241 wpa_printf(MSG_ERROR, "Failed to initialize driver "
2242 "'%s'", wpa_drivers[i]->name);
2243 return -1;
2244 }
2245 }
2246
2247 wpa_s->driver = wpa_drivers[i];
2248 wpa_s->global_drv_priv = global->drv_priv[i];
2249
2250 return 0;
2251}
2252
2253
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002254static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2255 const char *name)
2256{
2257 int i;
2258 size_t len;
2259 const char *pos, *driver = name;
2260
2261 if (wpa_s == NULL)
2262 return -1;
2263
2264 if (wpa_drivers[0] == NULL) {
2265 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2266 "wpa_supplicant");
2267 return -1;
2268 }
2269
2270 if (name == NULL) {
2271 /* default to first driver in the list */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002272 return select_driver(wpa_s, 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002273 }
2274
2275 do {
2276 pos = os_strchr(driver, ',');
2277 if (pos)
2278 len = pos - driver;
2279 else
2280 len = os_strlen(driver);
2281
2282 for (i = 0; wpa_drivers[i]; i++) {
2283 if (os_strlen(wpa_drivers[i]->name) == len &&
2284 os_strncmp(driver, wpa_drivers[i]->name, len) ==
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08002285 0) {
2286 /* First driver that succeeds wins */
2287 if (select_driver(wpa_s, i) == 0)
2288 return 0;
2289 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002290 }
2291
2292 driver = pos + 1;
2293 } while (pos);
2294
2295 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2296 return -1;
2297}
2298
2299
2300/**
2301 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2302 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2303 * with struct wpa_driver_ops::init()
2304 * @src_addr: Source address of the EAPOL frame
2305 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2306 * @len: Length of the EAPOL data
2307 *
2308 * This function is called for each received EAPOL frame. Most driver
2309 * interfaces rely on more generic OS mechanism for receiving frames through
2310 * l2_packet, but if such a mechanism is not available, the driver wrapper may
2311 * take care of received EAPOL frames and deliver them to the core supplicant
2312 * code by calling this function.
2313 */
2314void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
2315 const u8 *buf, size_t len)
2316{
2317 struct wpa_supplicant *wpa_s = ctx;
2318
2319 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2320 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
2321
Jouni Malinena05074c2012-12-21 21:35:35 +02002322 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2323 (wpa_s->last_eapol_matches_bssid &&
2324#ifdef CONFIG_AP
2325 !wpa_s->ap_iface &&
2326#endif /* CONFIG_AP */
2327 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002328 /*
2329 * There is possible race condition between receiving the
2330 * association event and the EAPOL frame since they are coming
2331 * through different paths from the driver. In order to avoid
2332 * issues in trying to process the EAPOL frame before receiving
2333 * association information, lets queue it for processing until
Jouni Malinena05074c2012-12-21 21:35:35 +02002334 * the association event is received. This may also be needed in
2335 * driver-based roaming case, so also use src_addr != BSSID as a
2336 * trigger if we have previously confirmed that the
2337 * Authenticator uses BSSID as the src_addr (which is not the
2338 * case with wired IEEE 802.1X).
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002339 */
2340 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
Jouni Malinena05074c2012-12-21 21:35:35 +02002341 "of received EAPOL frame (state=%s bssid=" MACSTR ")",
2342 wpa_supplicant_state_txt(wpa_s->wpa_state),
2343 MAC2STR(wpa_s->bssid));
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002344 wpabuf_free(wpa_s->pending_eapol_rx);
2345 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2346 if (wpa_s->pending_eapol_rx) {
2347 os_get_time(&wpa_s->pending_eapol_rx_time);
2348 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2349 ETH_ALEN);
2350 }
2351 return;
2352 }
2353
Jouni Malinena05074c2012-12-21 21:35:35 +02002354 wpa_s->last_eapol_matches_bssid =
2355 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2356
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002357#ifdef CONFIG_AP
2358 if (wpa_s->ap_iface) {
2359 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2360 return;
2361 }
2362#endif /* CONFIG_AP */
2363
2364 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2365 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2366 "no key management is configured");
2367 return;
2368 }
2369
2370 if (wpa_s->eapol_received == 0 &&
2371 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2372 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2373 wpa_s->wpa_state != WPA_COMPLETED) &&
2374 (wpa_s->current_ssid == NULL ||
2375 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2376 /* Timeout for completing IEEE 802.1X and WPA authentication */
2377 wpa_supplicant_req_auth_timeout(
2378 wpa_s,
2379 (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2380 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2381 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2382 70 : 10, 0);
2383 }
2384 wpa_s->eapol_received++;
2385
2386 if (wpa_s->countermeasures) {
2387 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2388 "EAPOL packet");
2389 return;
2390 }
2391
2392#ifdef CONFIG_IBSS_RSN
2393 if (wpa_s->current_ssid &&
2394 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2395 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2396 return;
2397 }
2398#endif /* CONFIG_IBSS_RSN */
2399
2400 /* Source address of the incoming EAPOL frame could be compared to the
2401 * current BSSID. However, it is possible that a centralized
2402 * Authenticator could be using another MAC address than the BSSID of
2403 * an AP, so just allow any address to be used for now. The replies are
2404 * still sent to the current BSSID (if available), though. */
2405
2406 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2407 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2408 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2409 return;
2410 wpa_drv_poll(wpa_s);
2411 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2412 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2413 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2414 /*
2415 * Set portValid = TRUE here since we are going to skip 4-way
2416 * handshake processing which would normally set portValid. We
2417 * need this to allow the EAPOL state machines to be completed
2418 * without going through EAPOL-Key handshake.
2419 */
2420 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2421 }
2422}
2423
2424
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002425int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002426{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002427 if (wpa_s->driver->send_eapol) {
2428 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2429 if (addr)
2430 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
Dmitry Shmidt34af3062013-07-11 10:46:32 -07002431 } else if ((!wpa_s->p2p_mgmt ||
2432 !(wpa_s->drv_flags &
2433 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
2434 !(wpa_s->drv_flags &
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002435 WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002436 l2_packet_deinit(wpa_s->l2);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002437 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2438 wpa_drv_get_mac_addr(wpa_s),
2439 ETH_P_EAPOL,
2440 wpa_supplicant_rx_eapol, wpa_s, 0);
2441 if (wpa_s->l2 == NULL)
2442 return -1;
2443 } else {
2444 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2445 if (addr)
2446 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2447 }
2448
2449 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2450 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2451 return -1;
2452 }
2453
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002454 return 0;
2455}
2456
2457
Dmitry Shmidt04949592012-07-19 12:16:46 -07002458static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
2459 const u8 *buf, size_t len)
2460{
2461 struct wpa_supplicant *wpa_s = ctx;
2462 const struct l2_ethhdr *eth;
2463
2464 if (len < sizeof(*eth))
2465 return;
2466 eth = (const struct l2_ethhdr *) buf;
2467
2468 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2469 !(eth->h_dest[0] & 0x01)) {
2470 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2471 " (bridge - not for this interface - ignore)",
2472 MAC2STR(src_addr), MAC2STR(eth->h_dest));
2473 return;
2474 }
2475
2476 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2477 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
2478 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2479 len - sizeof(*eth));
2480}
2481
2482
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002483/**
2484 * wpa_supplicant_driver_init - Initialize driver interface parameters
2485 * @wpa_s: Pointer to wpa_supplicant data
2486 * Returns: 0 on success, -1 on failure
2487 *
2488 * This function is called to initialize driver interface parameters.
2489 * wpa_drv_init() must have been called before this function to initialize the
2490 * driver interface.
2491 */
2492int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2493{
2494 static int interface_count = 0;
2495
2496 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2497 return -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002498
Dmitry Shmidt34af3062013-07-11 10:46:32 -07002499 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2500 MAC2STR(wpa_s->own_addr));
2501 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2502
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002503 if (wpa_s->bridge_ifname[0]) {
2504 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2505 "interface '%s'", wpa_s->bridge_ifname);
2506 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2507 wpa_s->own_addr,
2508 ETH_P_EAPOL,
Dmitry Shmidt04949592012-07-19 12:16:46 -07002509 wpa_supplicant_rx_eapol_bridge,
2510 wpa_s, 1);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002511 if (wpa_s->l2_br == NULL) {
2512 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2513 "connection for the bridge interface '%s'",
2514 wpa_s->bridge_ifname);
2515 return -1;
2516 }
2517 }
2518
2519 wpa_clear_keys(wpa_s, NULL);
2520
2521 /* Make sure that TKIP countermeasures are not left enabled (could
2522 * happen if wpa_supplicant is killed during countermeasures. */
2523 wpa_drv_set_countermeasures(wpa_s, 0);
2524
2525 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2526 wpa_drv_flush_pmkid(wpa_s);
2527
2528 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08002529 wpa_s->prev_scan_wildcard = 0;
2530
Dmitry Shmidt04949592012-07-19 12:16:46 -07002531 if (wpa_supplicant_enabled_networks(wpa_s)) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002532 if (wpa_supplicant_delayed_sched_scan(wpa_s, interface_count,
2533 100000))
2534 wpa_supplicant_req_scan(wpa_s, interface_count,
2535 100000);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002536 interface_count++;
2537 } else
2538 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2539
2540 return 0;
2541}
2542
2543
2544static int wpa_supplicant_daemon(const char *pid_file)
2545{
2546 wpa_printf(MSG_DEBUG, "Daemonize..");
2547 return os_daemonize(pid_file);
2548}
2549
2550
2551static struct wpa_supplicant * wpa_supplicant_alloc(void)
2552{
2553 struct wpa_supplicant *wpa_s;
2554
2555 wpa_s = os_zalloc(sizeof(*wpa_s));
2556 if (wpa_s == NULL)
2557 return NULL;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08002558 wpa_s->scan_req = INITIAL_SCAN_REQ;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002559 wpa_s->scan_interval = 5;
2560 wpa_s->new_connection = 1;
2561 wpa_s->parent = wpa_s;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002562 wpa_s->sched_scanning = 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002563
2564 return wpa_s;
2565}
2566
2567
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08002568#ifdef CONFIG_HT_OVERRIDES
2569
2570static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2571 struct ieee80211_ht_capabilities *htcaps,
2572 struct ieee80211_ht_capabilities *htcaps_mask,
2573 const char *ht_mcs)
2574{
2575 /* parse ht_mcs into hex array */
2576 int i;
2577 const char *tmp = ht_mcs;
2578 char *end = NULL;
2579
2580 /* If ht_mcs is null, do not set anything */
2581 if (!ht_mcs)
2582 return 0;
2583
2584 /* This is what we are setting in the kernel */
2585 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
2586
2587 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2588
2589 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2590 errno = 0;
2591 long v = strtol(tmp, &end, 16);
2592 if (errno == 0) {
2593 wpa_msg(wpa_s, MSG_DEBUG,
2594 "htcap value[%i]: %ld end: %p tmp: %p",
2595 i, v, end, tmp);
2596 if (end == tmp)
2597 break;
2598
2599 htcaps->supported_mcs_set[i] = v;
2600 tmp = end;
2601 } else {
2602 wpa_msg(wpa_s, MSG_ERROR,
2603 "Failed to parse ht-mcs: %s, error: %s\n",
2604 ht_mcs, strerror(errno));
2605 return -1;
2606 }
2607 }
2608
2609 /*
2610 * If we were able to parse any values, then set mask for the MCS set.
2611 */
2612 if (i) {
2613 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
2614 IEEE80211_HT_MCS_MASK_LEN - 1);
2615 /* skip the 3 reserved bits */
2616 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
2617 0x1f;
2618 }
2619
2620 return 0;
2621}
2622
2623
2624static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2625 struct ieee80211_ht_capabilities *htcaps,
2626 struct ieee80211_ht_capabilities *htcaps_mask,
2627 int disabled)
2628{
2629 u16 msk;
2630
2631 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2632
2633 if (disabled == -1)
2634 return 0;
2635
2636 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
2637 htcaps_mask->ht_capabilities_info |= msk;
2638 if (disabled)
2639 htcaps->ht_capabilities_info &= msk;
2640 else
2641 htcaps->ht_capabilities_info |= msk;
2642
2643 return 0;
2644}
2645
2646
2647static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
2648 struct ieee80211_ht_capabilities *htcaps,
2649 struct ieee80211_ht_capabilities *htcaps_mask,
2650 int factor)
2651{
2652 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
2653
2654 if (factor == -1)
2655 return 0;
2656
2657 if (factor < 0 || factor > 3) {
2658 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
2659 "Must be 0-3 or -1", factor);
2660 return -EINVAL;
2661 }
2662
2663 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
2664 htcaps->a_mpdu_params &= ~0x3;
2665 htcaps->a_mpdu_params |= factor & 0x3;
2666
2667 return 0;
2668}
2669
2670
2671static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
2672 struct ieee80211_ht_capabilities *htcaps,
2673 struct ieee80211_ht_capabilities *htcaps_mask,
2674 int density)
2675{
2676 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
2677
2678 if (density == -1)
2679 return 0;
2680
2681 if (density < 0 || density > 7) {
2682 wpa_msg(wpa_s, MSG_ERROR,
2683 "ampdu_density: %d out of range. Must be 0-7 or -1.",
2684 density);
2685 return -EINVAL;
2686 }
2687
2688 htcaps_mask->a_mpdu_params |= 0x1C;
2689 htcaps->a_mpdu_params &= ~(0x1C);
2690 htcaps->a_mpdu_params |= (density << 2) & 0x1C;
2691
2692 return 0;
2693}
2694
2695
2696static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
2697 struct ieee80211_ht_capabilities *htcaps,
2698 struct ieee80211_ht_capabilities *htcaps_mask,
2699 int disabled)
2700{
2701 /* Masking these out disables HT40 */
2702 u16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
2703 HT_CAP_INFO_SHORT_GI40MHZ);
2704
2705 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
2706
2707 if (disabled)
2708 htcaps->ht_capabilities_info &= ~msk;
2709 else
2710 htcaps->ht_capabilities_info |= msk;
2711
2712 htcaps_mask->ht_capabilities_info |= msk;
2713
2714 return 0;
2715}
2716
2717
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08002718static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
2719 struct ieee80211_ht_capabilities *htcaps,
2720 struct ieee80211_ht_capabilities *htcaps_mask,
2721 int disabled)
2722{
2723 /* Masking these out disables SGI */
2724 u16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
2725 HT_CAP_INFO_SHORT_GI40MHZ);
2726
2727 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
2728
2729 if (disabled)
2730 htcaps->ht_capabilities_info &= ~msk;
2731 else
2732 htcaps->ht_capabilities_info |= msk;
2733
2734 htcaps_mask->ht_capabilities_info |= msk;
2735
2736 return 0;
2737}
2738
2739
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08002740void wpa_supplicant_apply_ht_overrides(
2741 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2742 struct wpa_driver_associate_params *params)
2743{
2744 struct ieee80211_ht_capabilities *htcaps;
2745 struct ieee80211_ht_capabilities *htcaps_mask;
2746
2747 if (!ssid)
2748 return;
2749
2750 params->disable_ht = ssid->disable_ht;
2751 if (!params->htcaps || !params->htcaps_mask)
2752 return;
2753
2754 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
2755 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
2756 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
2757 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
2758 ssid->disable_max_amsdu);
2759 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
2760 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
2761 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -08002762 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08002763}
2764
2765#endif /* CONFIG_HT_OVERRIDES */
2766
2767
Dmitry Shmidt2f023192013-03-12 12:44:17 -07002768#ifdef CONFIG_VHT_OVERRIDES
2769void wpa_supplicant_apply_vht_overrides(
2770 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2771 struct wpa_driver_associate_params *params)
2772{
2773 struct ieee80211_vht_capabilities *vhtcaps;
2774 struct ieee80211_vht_capabilities *vhtcaps_mask;
2775
2776 if (!ssid)
2777 return;
2778
2779 params->disable_vht = ssid->disable_vht;
2780
2781 vhtcaps = (void *) params->vhtcaps;
2782 vhtcaps_mask = (void *) params->vhtcaps_mask;
2783
2784 if (!vhtcaps || !vhtcaps_mask)
2785 return;
2786
2787 vhtcaps->vht_capabilities_info = ssid->vht_capa;
2788 vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask;
2789
2790#define OVERRIDE_MCS(i) \
2791 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
2792 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
2793 3 << 2 * (i - 1); \
2794 vhtcaps->vht_supported_mcs_set.tx_map |= \
2795 ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1); \
2796 } \
2797 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
2798 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
2799 3 << 2 * (i - 1); \
2800 vhtcaps->vht_supported_mcs_set.rx_map |= \
2801 ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1); \
2802 }
2803
2804 OVERRIDE_MCS(1);
2805 OVERRIDE_MCS(2);
2806 OVERRIDE_MCS(3);
2807 OVERRIDE_MCS(4);
2808 OVERRIDE_MCS(5);
2809 OVERRIDE_MCS(6);
2810 OVERRIDE_MCS(7);
2811 OVERRIDE_MCS(8);
2812}
2813#endif /* CONFIG_VHT_OVERRIDES */
2814
2815
Dmitry Shmidt04949592012-07-19 12:16:46 -07002816static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
2817{
2818#ifdef PCSC_FUNCS
2819 size_t len;
2820
2821 if (!wpa_s->conf->pcsc_reader)
2822 return 0;
2823
Dmitry Shmidte0e48dc2013-11-18 12:00:06 -08002824 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
Dmitry Shmidt04949592012-07-19 12:16:46 -07002825 if (!wpa_s->scard)
2826 return 1;
2827
2828 if (wpa_s->conf->pcsc_pin &&
2829 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
2830 scard_deinit(wpa_s->scard);
2831 wpa_s->scard = NULL;
2832 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
2833 return -1;
2834 }
2835
2836 len = sizeof(wpa_s->imsi) - 1;
2837 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
2838 scard_deinit(wpa_s->scard);
2839 wpa_s->scard = NULL;
2840 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
2841 return -1;
2842 }
2843 wpa_s->imsi[len] = '\0';
2844
2845 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
2846
2847 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
2848 wpa_s->imsi, wpa_s->mnc_len);
2849
2850 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
2851 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
2852#endif /* PCSC_FUNCS */
2853
2854 return 0;
2855}
2856
2857
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07002858int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
2859{
2860 char *val, *pos;
2861
2862 ext_password_deinit(wpa_s->ext_pw);
2863 wpa_s->ext_pw = NULL;
2864 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
2865
2866 if (!wpa_s->conf->ext_password_backend)
2867 return 0;
2868
2869 val = os_strdup(wpa_s->conf->ext_password_backend);
2870 if (val == NULL)
2871 return -1;
2872 pos = os_strchr(val, ':');
2873 if (pos)
2874 *pos++ = '\0';
2875
2876 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
2877
2878 wpa_s->ext_pw = ext_password_init(val, pos);
2879 os_free(val);
2880 if (wpa_s->ext_pw == NULL) {
2881 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
2882 return -1;
2883 }
2884 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
2885
2886 return 0;
2887}
2888
2889
Dmitry Shmidt01904cf2013-12-05 11:08:35 -08002890static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
2891 const char *rn)
2892{
2893 struct wpa_supplicant *iface = wpa_s->global->ifaces;
2894 struct wpa_radio *radio;
2895
2896 while (rn && iface) {
2897 radio = iface->radio;
2898 if (radio && os_strcmp(rn, radio->name) == 0) {
2899 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
2900 wpa_s->ifname, rn);
2901 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
2902 return radio;
2903 }
2904 }
2905
2906 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
2907 wpa_s->ifname, rn ? rn : "N/A");
2908 radio = os_zalloc(sizeof(*radio));
2909 if (radio == NULL)
2910 return NULL;
2911
2912 if (rn)
2913 os_strlcpy(radio->name, rn, sizeof(radio->name));
2914 dl_list_init(&radio->ifaces);
2915 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
2916
2917 return radio;
2918}
2919
2920
2921static void radio_remove_interface(struct wpa_supplicant *wpa_s)
2922{
2923 struct wpa_radio *radio = wpa_s->radio;
2924
2925 if (!radio)
2926 return;
2927
2928 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
2929 wpa_s->ifname, radio->name);
2930 dl_list_del(&wpa_s->radio_list);
2931 wpa_s->radio = NULL;
2932
2933 if (!dl_list_empty(&radio->ifaces))
2934 return; /* Interfaces remain for this radio */
2935
2936 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
2937 os_free(radio);
2938}
2939
2940
2941static int wpas_init_driver(struct wpa_supplicant *wpa_s,
2942 struct wpa_interface *iface)
2943{
2944 const char *ifname, *driver, *rn;
2945
2946 driver = iface->driver;
2947next_driver:
2948 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
2949 return -1;
2950
2951 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
2952 if (wpa_s->drv_priv == NULL) {
2953 const char *pos;
2954 pos = driver ? os_strchr(driver, ',') : NULL;
2955 if (pos) {
2956 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
2957 "driver interface - try next driver wrapper");
2958 driver = pos + 1;
2959 goto next_driver;
2960 }
2961 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
2962 "interface");
2963 return -1;
2964 }
2965 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
2966 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
2967 "driver_param '%s'", wpa_s->conf->driver_param);
2968 return -1;
2969 }
2970
2971 ifname = wpa_drv_get_ifname(wpa_s);
2972 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
2973 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
2974 "interface name with '%s'", ifname);
2975 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2976 }
2977
2978 if (wpa_s->driver->get_radio_name)
2979 rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
2980 else
2981 rn = NULL;
2982 if (rn && rn[0] == '\0')
2983 rn = NULL;
2984
2985 wpa_s->radio = radio_add_interface(wpa_s, rn);
2986 if (wpa_s->radio == NULL)
2987 return -1;
2988
2989 return 0;
2990}
2991
2992
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002993static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
2994 struct wpa_interface *iface)
2995{
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002996 struct wpa_driver_capa capa;
2997
2998 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
2999 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
3000 iface->confname ? iface->confname : "N/A",
3001 iface->driver ? iface->driver : "default",
3002 iface->ctrl_interface ? iface->ctrl_interface : "N/A",
3003 iface->bridge_ifname ? iface->bridge_ifname : "N/A");
3004
3005 if (iface->confname) {
3006#ifdef CONFIG_BACKEND_FILE
3007 wpa_s->confname = os_rel2abs_path(iface->confname);
3008 if (wpa_s->confname == NULL) {
3009 wpa_printf(MSG_ERROR, "Failed to get absolute path "
3010 "for configuration file '%s'.",
3011 iface->confname);
3012 return -1;
3013 }
3014 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
3015 iface->confname, wpa_s->confname);
3016#else /* CONFIG_BACKEND_FILE */
3017 wpa_s->confname = os_strdup(iface->confname);
3018#endif /* CONFIG_BACKEND_FILE */
Dmitry Shmidt64f47c52013-04-16 10:41:54 -07003019 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003020 if (wpa_s->conf == NULL) {
3021 wpa_printf(MSG_ERROR, "Failed to read or parse "
3022 "configuration '%s'.", wpa_s->confname);
3023 return -1;
3024 }
Dmitry Shmidt64f47c52013-04-16 10:41:54 -07003025 wpa_s->confanother = os_rel2abs_path(iface->confanother);
3026 wpa_config_read(wpa_s->confanother, wpa_s->conf);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003027
3028 /*
3029 * Override ctrl_interface and driver_param if set on command
3030 * line.
3031 */
3032 if (iface->ctrl_interface) {
3033 os_free(wpa_s->conf->ctrl_interface);
3034 wpa_s->conf->ctrl_interface =
3035 os_strdup(iface->ctrl_interface);
3036 }
3037
3038 if (iface->driver_param) {
3039 os_free(wpa_s->conf->driver_param);
3040 wpa_s->conf->driver_param =
3041 os_strdup(iface->driver_param);
3042 }
Dmitry Shmidt34af3062013-07-11 10:46:32 -07003043
3044 if (iface->p2p_mgmt && !iface->ctrl_interface) {
3045 os_free(wpa_s->conf->ctrl_interface);
3046 wpa_s->conf->ctrl_interface = NULL;
3047 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003048 } else
3049 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
3050 iface->driver_param);
3051
3052 if (wpa_s->conf == NULL) {
3053 wpa_printf(MSG_ERROR, "\nNo configuration found.");
3054 return -1;
3055 }
3056
3057 if (iface->ifname == NULL) {
3058 wpa_printf(MSG_ERROR, "\nInterface name is required.");
3059 return -1;
3060 }
3061 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
3062 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
3063 iface->ifname);
3064 return -1;
3065 }
3066 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
3067
3068 if (iface->bridge_ifname) {
3069 if (os_strlen(iface->bridge_ifname) >=
3070 sizeof(wpa_s->bridge_ifname)) {
3071 wpa_printf(MSG_ERROR, "\nToo long bridge interface "
3072 "name '%s'.", iface->bridge_ifname);
3073 return -1;
3074 }
3075 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
3076 sizeof(wpa_s->bridge_ifname));
3077 }
3078
3079 /* RSNA Supplicant Key Management - INITIALIZE */
3080 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
3081 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
3082
3083 /* Initialize driver interface and register driver event handler before
3084 * L2 receive handler so that association events are processed before
3085 * EAPOL-Key packets if both become available for the same select()
3086 * call. */
Dmitry Shmidt01904cf2013-12-05 11:08:35 -08003087 if (wpas_init_driver(wpa_s, iface) < 0)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003088 return -1;
3089
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003090 if (wpa_supplicant_init_wpa(wpa_s) < 0)
3091 return -1;
3092
3093 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
3094 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
3095 NULL);
3096 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
3097
3098 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
3099 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
3100 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
3101 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3102 "dot11RSNAConfigPMKLifetime");
3103 return -1;
3104 }
3105
3106 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
3107 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
3108 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
3109 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3110 "dot11RSNAConfigPMKReauthThreshold");
3111 return -1;
3112 }
3113
3114 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
3115 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
3116 wpa_s->conf->dot11RSNAConfigSATimeout)) {
3117 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3118 "dot11RSNAConfigSATimeout");
3119 return -1;
3120 }
3121
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003122 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
3123 &wpa_s->hw.num_modes,
3124 &wpa_s->hw.flags);
3125
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003126 if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003127 wpa_s->drv_capa_known = 1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003128 wpa_s->drv_flags = capa.flags;
Dmitry Shmidt04949592012-07-19 12:16:46 -07003129 wpa_s->drv_enc = capa.enc;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003130 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003131 wpa_s->max_scan_ssids = capa.max_scan_ssids;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003132 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
3133 wpa_s->sched_scan_supported = capa.sched_scan_supported;
3134 wpa_s->max_match_sets = capa.max_match_sets;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003135 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
3136 wpa_s->max_stations = capa.max_stations;
Dmitry Shmidt444d5672013-04-01 13:08:44 -07003137 wpa_s->extended_capa = capa.extended_capa;
3138 wpa_s->extended_capa_mask = capa.extended_capa_mask;
3139 wpa_s->extended_capa_len = capa.extended_capa_len;
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07003140 wpa_s->num_multichan_concurrent =
3141 capa.num_multichan_concurrent;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003142 }
3143 if (wpa_s->max_remain_on_chan == 0)
3144 wpa_s->max_remain_on_chan = 1000;
3145
Dmitry Shmidt34af3062013-07-11 10:46:32 -07003146 /*
3147 * Only take p2p_mgmt parameters when P2P Device is supported.
3148 * Doing it here as it determines whether l2_packet_init() will be done
3149 * during wpa_supplicant_driver_init().
3150 */
3151 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
3152 wpa_s->p2p_mgmt = iface->p2p_mgmt;
3153 else
3154 iface->p2p_mgmt = 1;
3155
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07003156 if (wpa_s->num_multichan_concurrent == 0)
3157 wpa_s->num_multichan_concurrent = 1;
3158
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003159 if (wpa_supplicant_driver_init(wpa_s) < 0)
3160 return -1;
3161
3162#ifdef CONFIG_TDLS
Dmitry Shmidt34af3062013-07-11 10:46:32 -07003163 if ((!iface->p2p_mgmt ||
3164 !(wpa_s->drv_flags &
3165 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3166 wpa_tdls_init(wpa_s->wpa))
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003167 return -1;
3168#endif /* CONFIG_TDLS */
3169
3170 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3171 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
3172 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
3173 return -1;
3174 }
3175
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003176 if (wpas_wps_init(wpa_s))
3177 return -1;
3178
3179 if (wpa_supplicant_init_eapol(wpa_s) < 0)
3180 return -1;
3181 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3182
3183 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3184 if (wpa_s->ctrl_iface == NULL) {
3185 wpa_printf(MSG_ERROR,
3186 "Failed to initialize control interface '%s'.\n"
3187 "You may have another wpa_supplicant process "
3188 "already running or the file was\n"
3189 "left by an unclean termination of wpa_supplicant "
3190 "in which case you will need\n"
3191 "to manually remove this file before starting "
3192 "wpa_supplicant again.\n",
3193 wpa_s->conf->ctrl_interface);
3194 return -1;
3195 }
3196
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003197 wpa_s->gas = gas_query_init(wpa_s);
3198 if (wpa_s->gas == NULL) {
3199 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
3200 return -1;
3201 }
3202
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003203#ifdef CONFIG_P2P
Dmitry Shmidt34af3062013-07-11 10:46:32 -07003204 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003205 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
3206 return -1;
3207 }
3208#endif /* CONFIG_P2P */
3209
3210 if (wpa_bss_init(wpa_s) < 0)
3211 return -1;
3212
Dmitry Shmidt34af3062013-07-11 10:46:32 -07003213#ifdef CONFIG_EAP_PROXY
3214{
3215 size_t len;
Dmitry Shmidt4ce9c872013-10-24 11:08:13 -07003216 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
3217 &len);
Dmitry Shmidt34af3062013-07-11 10:46:32 -07003218 if (wpa_s->mnc_len > 0) {
3219 wpa_s->imsi[len] = '\0';
3220 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
3221 wpa_s->imsi, wpa_s->mnc_len);
3222 } else {
3223 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
3224 }
3225}
3226#endif /* CONFIG_EAP_PROXY */
3227
Dmitry Shmidt04949592012-07-19 12:16:46 -07003228 if (pcsc_reader_init(wpa_s) < 0)
3229 return -1;
3230
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003231 if (wpas_init_ext_pw(wpa_s) < 0)
3232 return -1;
3233
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003234 return 0;
3235}
3236
3237
3238static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003239 int notify, int terminate)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003240{
Dmitry Shmidtea69e842013-05-13 14:52:28 -07003241 wpa_s->disconnected = 1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003242 if (wpa_s->drv_priv) {
3243 wpa_supplicant_deauthenticate(wpa_s,
3244 WLAN_REASON_DEAUTH_LEAVING);
3245
3246 wpa_drv_set_countermeasures(wpa_s, 0);
3247 wpa_clear_keys(wpa_s, NULL);
3248 }
3249
3250 wpa_supplicant_cleanup(wpa_s);
3251
Dmitry Shmidt04949592012-07-19 12:16:46 -07003252#ifdef CONFIG_P2P
3253 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
3254 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
3255 "the management interface is being removed");
3256 wpas_p2p_deinit_global(wpa_s->global);
3257 }
3258#endif /* CONFIG_P2P */
3259
Dmitry Shmidt01904cf2013-12-05 11:08:35 -08003260 radio_remove_interface(wpa_s);
3261
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003262 if (wpa_s->drv_priv)
3263 wpa_drv_deinit(wpa_s);
Irfan Sheriff622b66d2011-08-03 09:11:49 -07003264
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003265 if (notify)
3266 wpas_notify_iface_removed(wpa_s);
3267
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003268 if (terminate)
3269 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
Irfan Sheriff622b66d2011-08-03 09:11:49 -07003270
3271 if (wpa_s->ctrl_iface) {
3272 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3273 wpa_s->ctrl_iface = NULL;
3274 }
3275
3276 if (wpa_s->conf != NULL) {
Irfan Sheriff622b66d2011-08-03 09:11:49 -07003277 wpa_config_free(wpa_s->conf);
3278 wpa_s->conf = NULL;
3279 }
Dmitry Shmidt8da800a2013-04-24 12:57:01 -07003280
3281 os_free(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003282}
3283
3284
3285/**
3286 * wpa_supplicant_add_iface - Add a new network interface
3287 * @global: Pointer to global data from wpa_supplicant_init()
3288 * @iface: Interface configuration options
3289 * Returns: Pointer to the created interface or %NULL on failure
3290 *
3291 * This function is used to add new network interfaces for %wpa_supplicant.
3292 * This can be called before wpa_supplicant_run() to add interfaces before the
3293 * main event loop has been started. In addition, new interfaces can be added
3294 * dynamically while %wpa_supplicant is already running. This could happen,
3295 * e.g., when a hotplug network adapter is inserted.
3296 */
3297struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
3298 struct wpa_interface *iface)
3299{
3300 struct wpa_supplicant *wpa_s;
3301 struct wpa_interface t_iface;
3302 struct wpa_ssid *ssid;
3303
3304 if (global == NULL || iface == NULL)
3305 return NULL;
3306
3307 wpa_s = wpa_supplicant_alloc();
3308 if (wpa_s == NULL)
3309 return NULL;
3310
3311 wpa_s->global = global;
3312
3313 t_iface = *iface;
3314 if (global->params.override_driver) {
3315 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
3316 "('%s' -> '%s')",
3317 iface->driver, global->params.override_driver);
3318 t_iface.driver = global->params.override_driver;
3319 }
3320 if (global->params.override_ctrl_interface) {
3321 wpa_printf(MSG_DEBUG, "Override interface parameter: "
3322 "ctrl_interface ('%s' -> '%s')",
3323 iface->ctrl_interface,
3324 global->params.override_ctrl_interface);
3325 t_iface.ctrl_interface =
3326 global->params.override_ctrl_interface;
3327 }
3328 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
3329 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
3330 iface->ifname);
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003331 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003332 return NULL;
3333 }
3334
3335 /* Notify the control interfaces about new iface */
3336 if (wpas_notify_iface_added(wpa_s)) {
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003337 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003338 return NULL;
3339 }
3340
3341 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3342 wpas_notify_network_added(wpa_s, ssid);
3343
3344 wpa_s->next = global->ifaces;
3345 global->ifaces = wpa_s;
3346
3347 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
Dmitry Shmidt04949592012-07-19 12:16:46 -07003348 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003349
3350 return wpa_s;
3351}
3352
3353
3354/**
3355 * wpa_supplicant_remove_iface - Remove a network interface
3356 * @global: Pointer to global data from wpa_supplicant_init()
3357 * @wpa_s: Pointer to the network interface to be removed
3358 * Returns: 0 if interface was removed, -1 if interface was not found
3359 *
3360 * This function can be used to dynamically remove network interfaces from
3361 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
3362 * addition, this function is used to remove all remaining interfaces when
3363 * %wpa_supplicant is terminated.
3364 */
3365int wpa_supplicant_remove_iface(struct wpa_global *global,
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003366 struct wpa_supplicant *wpa_s,
3367 int terminate)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003368{
3369 struct wpa_supplicant *prev;
3370
3371 /* Remove interface from the global list of interfaces */
3372 prev = global->ifaces;
3373 if (prev == wpa_s) {
3374 global->ifaces = wpa_s->next;
3375 } else {
3376 while (prev && prev->next != wpa_s)
3377 prev = prev->next;
3378 if (prev == NULL)
3379 return -1;
3380 prev->next = wpa_s->next;
3381 }
3382
3383 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3384
3385 if (global->p2p_group_formation == wpa_s)
3386 global->p2p_group_formation = NULL;
Dmitry Shmidt700a1372013-03-15 14:14:44 -07003387 if (global->p2p_invite_group == wpa_s)
3388 global->p2p_invite_group = NULL;
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003389 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003390
3391 return 0;
3392}
3393
3394
3395/**
3396 * wpa_supplicant_get_eap_mode - Get the current EAP mode
3397 * @wpa_s: Pointer to the network interface
3398 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
3399 */
3400const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3401{
3402 const char *eapol_method;
3403
3404 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3405 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3406 return "NO-EAP";
3407 }
3408
3409 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
3410 if (eapol_method == NULL)
3411 return "UNKNOWN-EAP";
3412
3413 return eapol_method;
3414}
3415
3416
3417/**
3418 * wpa_supplicant_get_iface - Get a new network interface
3419 * @global: Pointer to global data from wpa_supplicant_init()
3420 * @ifname: Interface name
3421 * Returns: Pointer to the interface or %NULL if not found
3422 */
3423struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
3424 const char *ifname)
3425{
3426 struct wpa_supplicant *wpa_s;
3427
3428 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3429 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3430 return wpa_s;
3431 }
3432 return NULL;
3433}
3434
3435
3436#ifndef CONFIG_NO_WPA_MSG
3437static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
3438{
3439 struct wpa_supplicant *wpa_s = ctx;
3440 if (wpa_s == NULL)
3441 return NULL;
3442 return wpa_s->ifname;
3443}
3444#endif /* CONFIG_NO_WPA_MSG */
3445
3446
3447/**
3448 * wpa_supplicant_init - Initialize %wpa_supplicant
3449 * @params: Parameters for %wpa_supplicant
3450 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
3451 *
3452 * This function is used to initialize %wpa_supplicant. After successful
3453 * initialization, the returned data pointer can be used to add and remove
3454 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
3455 */
3456struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
3457{
3458 struct wpa_global *global;
3459 int ret, i;
3460
3461 if (params == NULL)
3462 return NULL;
3463
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003464#ifdef CONFIG_DRIVER_NDIS
3465 {
3466 void driver_ndis_init_ops(void);
3467 driver_ndis_init_ops();
3468 }
3469#endif /* CONFIG_DRIVER_NDIS */
3470
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003471#ifndef CONFIG_NO_WPA_MSG
3472 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
3473#endif /* CONFIG_NO_WPA_MSG */
3474
3475 wpa_debug_open_file(params->wpa_debug_file_path);
3476 if (params->wpa_debug_syslog)
3477 wpa_debug_open_syslog();
Dmitry Shmidt04949592012-07-19 12:16:46 -07003478 if (params->wpa_debug_tracing) {
3479 ret = wpa_debug_open_linux_tracing();
3480 if (ret) {
3481 wpa_printf(MSG_ERROR,
3482 "Failed to enable trace logging");
3483 return NULL;
3484 }
3485 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003486
3487 ret = eap_register_methods();
3488 if (ret) {
3489 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
3490 if (ret == -2)
3491 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
3492 "the same EAP type.");
3493 return NULL;
3494 }
3495
3496 global = os_zalloc(sizeof(*global));
3497 if (global == NULL)
3498 return NULL;
3499 dl_list_init(&global->p2p_srv_bonjour);
3500 dl_list_init(&global->p2p_srv_upnp);
3501 global->params.daemonize = params->daemonize;
3502 global->params.wait_for_monitor = params->wait_for_monitor;
3503 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
3504 if (params->pid_file)
3505 global->params.pid_file = os_strdup(params->pid_file);
3506 if (params->ctrl_interface)
3507 global->params.ctrl_interface =
3508 os_strdup(params->ctrl_interface);
Dmitry Shmidtb6e9aaf2013-05-20 14:49:44 -07003509 if (params->ctrl_interface_group)
3510 global->params.ctrl_interface_group =
3511 os_strdup(params->ctrl_interface_group);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003512 if (params->override_driver)
3513 global->params.override_driver =
3514 os_strdup(params->override_driver);
3515 if (params->override_ctrl_interface)
3516 global->params.override_ctrl_interface =
3517 os_strdup(params->override_ctrl_interface);
3518 wpa_debug_level = global->params.wpa_debug_level =
3519 params->wpa_debug_level;
3520 wpa_debug_show_keys = global->params.wpa_debug_show_keys =
3521 params->wpa_debug_show_keys;
3522 wpa_debug_timestamp = global->params.wpa_debug_timestamp =
3523 params->wpa_debug_timestamp;
3524
3525 wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
3526
3527 if (eloop_init()) {
3528 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
3529 wpa_supplicant_deinit(global);
3530 return NULL;
3531 }
3532
Jouni Malinen75ecf522011-06-27 15:19:46 -07003533 random_init(params->entropy_file);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003534
3535 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
3536 if (global->ctrl_iface == NULL) {
3537 wpa_supplicant_deinit(global);
3538 return NULL;
3539 }
3540
3541 if (wpas_notify_supplicant_initialized(global)) {
3542 wpa_supplicant_deinit(global);
3543 return NULL;
3544 }
3545
3546 for (i = 0; wpa_drivers[i]; i++)
3547 global->drv_count++;
3548 if (global->drv_count == 0) {
3549 wpa_printf(MSG_ERROR, "No drivers enabled");
3550 wpa_supplicant_deinit(global);
3551 return NULL;
3552 }
3553 global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
3554 if (global->drv_priv == NULL) {
3555 wpa_supplicant_deinit(global);
3556 return NULL;
3557 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003558
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003559#ifdef CONFIG_WIFI_DISPLAY
3560 if (wifi_display_init(global) < 0) {
3561 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
3562 wpa_supplicant_deinit(global);
3563 return NULL;
3564 }
3565#endif /* CONFIG_WIFI_DISPLAY */
3566
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003567 return global;
3568}
3569
3570
3571/**
3572 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
3573 * @global: Pointer to global data from wpa_supplicant_init()
3574 * Returns: 0 after successful event loop run, -1 on failure
3575 *
3576 * This function starts the main event loop and continues running as long as
3577 * there are any remaining events. In most cases, this function is running as
3578 * long as the %wpa_supplicant process in still in use.
3579 */
3580int wpa_supplicant_run(struct wpa_global *global)
3581{
3582 struct wpa_supplicant *wpa_s;
3583
3584 if (global->params.daemonize &&
3585 wpa_supplicant_daemon(global->params.pid_file))
3586 return -1;
3587
3588 if (global->params.wait_for_monitor) {
3589 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
3590 if (wpa_s->ctrl_iface)
3591 wpa_supplicant_ctrl_iface_wait(
3592 wpa_s->ctrl_iface);
3593 }
3594
3595 eloop_register_signal_terminate(wpa_supplicant_terminate, global);
3596 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
3597
3598 eloop_run();
3599
3600 return 0;
3601}
3602
3603
3604/**
3605 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
3606 * @global: Pointer to global data from wpa_supplicant_init()
3607 *
3608 * This function is called to deinitialize %wpa_supplicant and to free all
3609 * allocated resources. Remaining network interfaces will also be removed.
3610 */
3611void wpa_supplicant_deinit(struct wpa_global *global)
3612{
3613 int i;
3614
3615 if (global == NULL)
3616 return;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003617
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003618#ifdef CONFIG_WIFI_DISPLAY
3619 wifi_display_deinit(global);
3620#endif /* CONFIG_WIFI_DISPLAY */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003621
3622 while (global->ifaces)
Dmitry Shmidte15c7b52011-08-03 15:04:35 -07003623 wpa_supplicant_remove_iface(global, global->ifaces, 1);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003624
3625 if (global->ctrl_iface)
3626 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
3627
3628 wpas_notify_supplicant_deinitialized(global);
3629
3630 eap_peer_unregister_methods();
3631#ifdef CONFIG_AP
3632 eap_server_unregister_methods();
3633#endif /* CONFIG_AP */
3634
3635 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
3636 if (!global->drv_priv[i])
3637 continue;
3638 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
3639 }
3640 os_free(global->drv_priv);
3641
3642 random_deinit();
3643
3644 eloop_destroy();
3645
3646 if (global->params.pid_file) {
3647 os_daemonize_terminate(global->params.pid_file);
3648 os_free(global->params.pid_file);
3649 }
3650 os_free(global->params.ctrl_interface);
Dmitry Shmidtb6e9aaf2013-05-20 14:49:44 -07003651 os_free(global->params.ctrl_interface_group);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003652 os_free(global->params.override_driver);
3653 os_free(global->params.override_ctrl_interface);
3654
Dmitry Shmidt4ce9c872013-10-24 11:08:13 -07003655 os_free(global->p2p_disallow_freq.range);
Dmitry Shmidt391c59f2013-09-03 12:16:28 -07003656 os_free(global->add_psk);
Dmitry Shmidt04949592012-07-19 12:16:46 -07003657
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003658 os_free(global);
3659 wpa_debug_close_syslog();
3660 wpa_debug_close_file();
Dmitry Shmidt04949592012-07-19 12:16:46 -07003661 wpa_debug_close_linux_tracing();
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003662}
3663
3664
3665void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
3666{
3667 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
3668 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3669 char country[3];
3670 country[0] = wpa_s->conf->country[0];
3671 country[1] = wpa_s->conf->country[1];
3672 country[2] = '\0';
3673 if (wpa_drv_set_country(wpa_s, country) < 0) {
3674 wpa_printf(MSG_ERROR, "Failed to set country code "
3675 "'%s'", country);
3676 }
3677 }
3678
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003679 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
3680 wpas_init_ext_pw(wpa_s);
3681
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003682#ifdef CONFIG_WPS
3683 wpas_wps_update_config(wpa_s);
3684#endif /* CONFIG_WPS */
3685
3686#ifdef CONFIG_P2P
3687 wpas_p2p_update_config(wpa_s);
3688#endif /* CONFIG_P2P */
3689
3690 wpa_s->conf->changed_parameters = 0;
3691}
3692
3693
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003694static void add_freq(int *freqs, int *num_freqs, int freq)
3695{
3696 int i;
3697
3698 for (i = 0; i < *num_freqs; i++) {
3699 if (freqs[i] == freq)
3700 return;
3701 }
3702
3703 freqs[*num_freqs] = freq;
3704 (*num_freqs)++;
3705}
3706
3707
3708static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
3709{
3710 struct wpa_bss *bss, *cbss;
3711 const int max_freqs = 10;
3712 int *freqs;
3713 int num_freqs = 0;
3714
3715 freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
3716 if (freqs == NULL)
3717 return NULL;
3718
3719 cbss = wpa_s->current_bss;
3720
3721 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
3722 if (bss == cbss)
3723 continue;
3724 if (bss->ssid_len == cbss->ssid_len &&
3725 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
3726 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
3727 add_freq(freqs, &num_freqs, bss->freq);
3728 if (num_freqs == max_freqs)
3729 break;
3730 }
3731 }
3732
3733 if (num_freqs == 0) {
3734 os_free(freqs);
3735 freqs = NULL;
3736 }
3737
3738 return freqs;
3739}
3740
3741
3742void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
3743{
3744 int timeout;
3745 int count;
3746 int *freqs = NULL;
3747
3748 /*
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003749 * Remove possible authentication timeout since the connection failed.
3750 */
3751 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
3752
Dmitry Shmidtea69e842013-05-13 14:52:28 -07003753 if (wpa_s->disconnected) {
3754 /*
3755 * There is no point in blacklisting the AP if this event is
3756 * generated based on local request to disconnect.
3757 */
3758 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
3759 "indication since interface has been put into "
3760 "disconnected state");
3761 return;
3762 }
3763
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003764 /*
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003765 * Add the failed BSSID into the blacklist and speed up next scan
3766 * attempt if there could be other APs that could accept association.
3767 * The current blacklist count indicates how many times we have tried
3768 * connecting to this AP and multiple attempts mean that other APs are
3769 * either not available or has already been tried, so that we can start
3770 * increasing the delay here to avoid constant scanning.
3771 */
3772 count = wpa_blacklist_add(wpa_s, bssid);
3773 if (count == 1 && wpa_s->current_bss) {
3774 /*
3775 * This BSS was not in the blacklist before. If there is
3776 * another BSS available for the same ESS, we should try that
3777 * next. Otherwise, we may as well try this one once more
3778 * before allowing other, likely worse, ESSes to be considered.
3779 */
3780 freqs = get_bss_freqs_in_ess(wpa_s);
3781 if (freqs) {
3782 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
3783 "has been seen; try it next");
3784 wpa_blacklist_add(wpa_s, bssid);
3785 /*
3786 * On the next scan, go through only the known channels
3787 * used in this ESS based on previous scans to speed up
3788 * common load balancing use case.
3789 */
3790 os_free(wpa_s->next_scan_freqs);
3791 wpa_s->next_scan_freqs = freqs;
3792 }
3793 }
3794
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08003795 /*
3796 * Add previous failure count in case the temporary blacklist was
3797 * cleared due to no other BSSes being available.
3798 */
3799 count += wpa_s->extra_blacklist_count;
3800
Dmitry Shmidt4b060592013-04-29 16:42:49 -07003801 if (count > 3 && wpa_s->current_ssid) {
3802 wpa_printf(MSG_DEBUG, "Continuous association failures - "
3803 "consider temporary network disabling");
3804 wpas_auth_failed(wpa_s);
3805 }
3806
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003807 switch (count) {
3808 case 1:
3809 timeout = 100;
3810 break;
3811 case 2:
3812 timeout = 500;
3813 break;
3814 case 3:
3815 timeout = 1000;
3816 break;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08003817 case 4:
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003818 timeout = 5000;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08003819 break;
3820 default:
3821 timeout = 10000;
3822 break;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003823 }
3824
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08003825 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
3826 "ms", count, timeout);
3827
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003828 /*
3829 * TODO: if more than one possible AP is available in scan results,
3830 * could try the other ones before requesting a new scan.
3831 */
3832 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
3833 1000 * (timeout % 1000));
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003834
Dmitry Shmidt37d4d6a2013-03-18 13:09:42 -07003835 wpas_p2p_continue_after_scan(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07003836}
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08003837
3838
3839int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
3840{
3841 return wpa_s->conf->ap_scan == 2 ||
3842 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
3843}
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003844
Dmitry Shmidt04949592012-07-19 12:16:46 -07003845
3846#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
3847int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
3848 struct wpa_ssid *ssid,
3849 const char *field,
3850 const char *value)
3851{
3852#ifdef IEEE8021X_EAPOL
3853 struct eap_peer_config *eap = &ssid->eap;
3854
3855 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
3856 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
3857 (const u8 *) value, os_strlen(value));
3858
3859 switch (wpa_supplicant_ctrl_req_from_string(field)) {
3860 case WPA_CTRL_REQ_EAP_IDENTITY:
3861 os_free(eap->identity);
3862 eap->identity = (u8 *) os_strdup(value);
3863 eap->identity_len = os_strlen(value);
3864 eap->pending_req_identity = 0;
3865 if (ssid == wpa_s->current_ssid)
3866 wpa_s->reassociate = 1;
3867 break;
3868 case WPA_CTRL_REQ_EAP_PASSWORD:
3869 os_free(eap->password);
3870 eap->password = (u8 *) os_strdup(value);
3871 eap->password_len = os_strlen(value);
3872 eap->pending_req_password = 0;
3873 if (ssid == wpa_s->current_ssid)
3874 wpa_s->reassociate = 1;
3875 break;
3876 case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
3877 os_free(eap->new_password);
3878 eap->new_password = (u8 *) os_strdup(value);
3879 eap->new_password_len = os_strlen(value);
3880 eap->pending_req_new_password = 0;
3881 if (ssid == wpa_s->current_ssid)
3882 wpa_s->reassociate = 1;
3883 break;
3884 case WPA_CTRL_REQ_EAP_PIN:
3885 os_free(eap->pin);
3886 eap->pin = os_strdup(value);
3887 eap->pending_req_pin = 0;
3888 if (ssid == wpa_s->current_ssid)
3889 wpa_s->reassociate = 1;
3890 break;
3891 case WPA_CTRL_REQ_EAP_OTP:
3892 os_free(eap->otp);
3893 eap->otp = (u8 *) os_strdup(value);
3894 eap->otp_len = os_strlen(value);
3895 os_free(eap->pending_req_otp);
3896 eap->pending_req_otp = NULL;
3897 eap->pending_req_otp_len = 0;
3898 break;
3899 case WPA_CTRL_REQ_EAP_PASSPHRASE:
3900 os_free(eap->private_key_passwd);
3901 eap->private_key_passwd = (u8 *) os_strdup(value);
3902 eap->pending_req_passphrase = 0;
3903 if (ssid == wpa_s->current_ssid)
3904 wpa_s->reassociate = 1;
3905 break;
Dmitry Shmidt051af732013-10-22 13:52:46 -07003906 case WPA_CTRL_REQ_SIM:
3907 os_free(eap->external_sim_resp);
3908 eap->external_sim_resp = os_strdup(value);
3909 break;
Dmitry Shmidt04949592012-07-19 12:16:46 -07003910 default:
3911 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
3912 return -1;
3913 }
3914
3915 return 0;
3916#else /* IEEE8021X_EAPOL */
3917 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
3918 return -1;
3919#endif /* IEEE8021X_EAPOL */
3920}
3921#endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
3922
3923
3924int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
3925{
3926 int i;
3927 unsigned int drv_enc;
3928
3929 if (ssid == NULL)
3930 return 1;
3931
3932 if (ssid->disabled)
3933 return 1;
3934
3935 if (wpa_s && wpa_s->drv_capa_known)
3936 drv_enc = wpa_s->drv_enc;
3937 else
3938 drv_enc = (unsigned int) -1;
3939
3940 for (i = 0; i < NUM_WEP_KEYS; i++) {
3941 size_t len = ssid->wep_key_len[i];
3942 if (len == 0)
3943 continue;
3944 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
3945 continue;
3946 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
3947 continue;
3948 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
3949 continue;
3950 return 1; /* invalid WEP key */
3951 }
3952
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003953 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
3954 !ssid->ext_psk)
3955 return 1;
3956
Dmitry Shmidt04949592012-07-19 12:16:46 -07003957 return 0;
3958}
3959
3960
Dmitry Shmidt687922c2012-03-26 14:02:32 -07003961int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003962{
Dmitry Shmidt2fb777c2012-05-02 12:29:53 -07003963 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003964 return 1;
Dmitry Shmidt2fb777c2012-05-02 12:29:53 -07003965 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
Dmitry Shmidt687922c2012-03-26 14:02:32 -07003966 return 0;
Dmitry Shmidt687922c2012-03-26 14:02:32 -07003967 return -1;
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08003968}
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003969
3970
3971void wpas_auth_failed(struct wpa_supplicant *wpa_s)
3972{
3973 struct wpa_ssid *ssid = wpa_s->current_ssid;
3974 int dur;
3975 struct os_time now;
3976
3977 if (ssid == NULL) {
3978 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
3979 "SSID block");
3980 return;
3981 }
3982
3983 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
3984 return;
3985
3986 ssid->auth_failures++;
Dmitry Shmidtd5c075b2013-08-05 14:36:10 -07003987
3988#ifdef CONFIG_P2P
3989 if (ssid->p2p_group &&
3990 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
3991 /*
3992 * Skip the wait time since there is a short timeout on the
3993 * connection to a P2P group.
3994 */
3995 return;
3996 }
3997#endif /* CONFIG_P2P */
3998
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07003999 if (ssid->auth_failures > 50)
4000 dur = 300;
4001 else if (ssid->auth_failures > 20)
4002 dur = 120;
4003 else if (ssid->auth_failures > 10)
4004 dur = 60;
4005 else if (ssid->auth_failures > 5)
4006 dur = 30;
4007 else if (ssid->auth_failures > 1)
4008 dur = 20;
4009 else
4010 dur = 10;
4011
4012 os_get_time(&now);
4013 if (now.sec + dur <= ssid->disabled_until.sec)
4014 return;
4015
4016 ssid->disabled_until.sec = now.sec + dur;
4017
4018 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
4019 "id=%d ssid=\"%s\" auth_failures=%u duration=%d",
4020 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
4021 ssid->auth_failures, dur);
4022}
4023
4024
4025void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
4026 struct wpa_ssid *ssid, int clear_failures)
4027{
4028 if (ssid == NULL)
4029 return;
4030
4031 if (ssid->disabled_until.sec) {
4032 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
4033 "id=%d ssid=\"%s\"",
4034 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
4035 }
4036 ssid->disabled_until.sec = 0;
4037 ssid->disabled_until.usec = 0;
4038 if (clear_failures)
4039 ssid->auth_failures = 0;
4040}
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08004041
4042
4043int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
4044{
4045 size_t i;
4046
4047 if (wpa_s->disallow_aps_bssid == NULL)
4048 return 0;
4049
4050 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
4051 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
4052 bssid, ETH_ALEN) == 0)
4053 return 1;
4054 }
4055
4056 return 0;
4057}
4058
4059
4060int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
4061 size_t ssid_len)
4062{
4063 size_t i;
4064
4065 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
4066 return 0;
4067
4068 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
4069 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
4070 if (ssid_len == s->ssid_len &&
4071 os_memcmp(ssid, s->ssid, ssid_len) == 0)
4072 return 1;
4073 }
4074
4075 return 0;
4076}
4077
4078
4079/**
4080 * wpas_request_connection - Request a new connection
4081 * @wpa_s: Pointer to the network interface
4082 *
4083 * This function is used to request a new connection to be found. It will mark
4084 * the interface to allow reassociation and request a new scan to find a
4085 * suitable network to connect to.
4086 */
4087void wpas_request_connection(struct wpa_supplicant *wpa_s)
4088{
4089 wpa_s->normal_scans = 0;
4090 wpa_supplicant_reinit_autoscan(wpa_s);
4091 wpa_s->extra_blacklist_count = 0;
4092 wpa_s->disconnected = 0;
4093 wpa_s->reassociate = 1;
Dmitry Shmidt2f3b8de2013-03-01 09:32:50 -08004094
4095 if (wpa_supplicant_fast_associate(wpa_s) != 1)
4096 wpa_supplicant_req_scan(wpa_s, 0, 0);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08004097}
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004098
4099
Dmitry Shmidt051af732013-10-22 13:52:46 -07004100static int wpas_conn_in_progress(struct wpa_supplicant *wpa_s)
4101{
4102 return wpa_s->wpa_state >= WPA_AUTHENTICATING &&
4103 wpa_s->wpa_state != WPA_COMPLETED;
4104}
4105
4106
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004107/**
4108 * wpas_wpa_is_in_progress - Check whether a connection is in progress
4109 * @wpa_s: Pointer to wpa_supplicant data
Dmitry Shmidt051af732013-10-22 13:52:46 -07004110 * @include_current: Whether to consider specified interface
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004111 *
4112 * This function is to check if the wpa state is in beginning of the connection
4113 * during 4-way handshake or group key handshake with WPA on any shared
4114 * interface.
4115 */
Dmitry Shmidt051af732013-10-22 13:52:46 -07004116int wpas_wpa_is_in_progress(struct wpa_supplicant *wpa_s, int include_current)
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004117{
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004118 struct wpa_supplicant *ifs;
4119
Dmitry Shmidt01904cf2013-12-05 11:08:35 -08004120 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
4121 radio_list) {
Dmitry Shmidt051af732013-10-22 13:52:46 -07004122 if (!include_current && ifs == wpa_s)
4123 continue;
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004124
Dmitry Shmidt051af732013-10-22 13:52:46 -07004125 if (wpas_conn_in_progress(ifs)) {
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004126 wpa_dbg(wpa_s, MSG_DEBUG, "Connection is in progress "
Dmitry Shmidt051af732013-10-22 13:52:46 -07004127 "on interface %s - defer", ifs->ifname);
Dmitry Shmidtea69e842013-05-13 14:52:28 -07004128 return 1;
4129 }
4130 }
4131
4132 return 0;
4133}
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07004134
4135
Dmitry Shmidtb96dad42013-11-05 10:07:29 -08004136void dump_freq_array(struct wpa_supplicant *wpa_s, const char *title,
4137 int *freq_array, unsigned int len)
4138{
4139 unsigned int i;
4140
4141 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
4142 len, title);
4143 for (i = 0; i < len; i++)
4144 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d", i, freq_array[i]);
4145}
4146
4147
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07004148/*
4149 * Find the operating frequencies of any of the virtual interfaces that
4150 * are using the same radio as the current interface.
4151 */
4152int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
4153 int *freq_array, unsigned int len)
4154{
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07004155 struct wpa_supplicant *ifs;
4156 u8 bssid[ETH_ALEN];
4157 int freq;
4158 unsigned int idx = 0, i;
4159
Dmitry Shmidtb96dad42013-11-05 10:07:29 -08004160 wpa_dbg(wpa_s, MSG_DEBUG,
4161 "Determining shared radio frequencies (max len %u)", len);
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07004162 os_memset(freq_array, 0, sizeof(int) * len);
4163
4164 /* First add the frequency of the local interface */
4165 if (wpa_s->current_ssid != NULL && wpa_s->assoc_freq != 0) {
4166 if (wpa_s->current_ssid->mode == WPAS_MODE_AP ||
4167 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO)
4168 freq_array[idx++] = wpa_s->current_ssid->frequency;
4169 else if (wpa_drv_get_bssid(wpa_s, bssid) == 0)
4170 freq_array[idx++] = wpa_s->assoc_freq;
4171 }
4172
4173 /* If get_radio_name is not supported, use only the local freq */
4174 if (!wpa_s->driver->get_radio_name) {
4175 freq = wpa_drv_shared_freq(wpa_s);
4176 if (freq > 0 && idx < len &&
4177 (idx == 0 || freq_array[0] != freq))
4178 freq_array[idx++] = freq;
Dmitry Shmidtb96dad42013-11-05 10:07:29 -08004179 dump_freq_array(wpa_s, "No get_radio_name", freq_array, idx);
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07004180 return idx;
4181 }
4182
Dmitry Shmidt01904cf2013-12-05 11:08:35 -08004183 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
4184 radio_list) {
4185 if (wpa_s == ifs)
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07004186 continue;
4187
4188 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
4189 continue;
4190
4191 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
4192 ifs->current_ssid->mode == WPAS_MODE_P2P_GO)
4193 freq = ifs->current_ssid->frequency;
4194 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
4195 freq = ifs->assoc_freq;
4196 else
4197 continue;
4198
4199 /* Hold only distinct freqs */
4200 for (i = 0; i < idx; i++)
4201 if (freq_array[i] == freq)
4202 break;
4203
4204 if (i == idx)
4205 freq_array[idx++] = freq;
4206 }
Dmitry Shmidtb96dad42013-11-05 10:07:29 -08004207
4208 dump_freq_array(wpa_s, "completed iteration", freq_array, idx);
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -07004209 return idx;
4210}