3
* Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
5
* This program is free software; you can redistribute it and/or modify
6
* it under the terms of the GNU General Public License version 2 as
7
* published by the Free Software Foundation.
9
* Alternatively, this software may be distributed under the terms of BSD
12
* See README and COPYING for more details.
14
* This file implements functions for registering and unregistering
15
* %wpa_supplicant interfaces. In addition, this file contains number of
16
* functions for managing network connections.
22
#include "eapol_supp/eapol_supp_sm.h"
23
#include "eap_peer/eap.h"
26
#include "drivers/driver.h"
28
#include "l2_packet/l2_packet.h"
29
#include "wpa_supplicant_i.h"
30
#include "ctrl_iface.h"
31
#include "ctrl_iface_dbus.h"
32
#include "pcsc_funcs.h"
35
#include "pmksa_cache.h"
38
#include "ieee802_11_defs.h"
39
#include "blacklist.h"
40
#include "wpas_glue.h"
42
const char *wpa_supplicant_version =
43
"wpa_supplicant v" VERSION_STR "\n"
44
"Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi> and contributors";
46
const char *wpa_supplicant_license =
47
"This program is free software. You can distribute it and/or modify it\n"
48
"under the terms of the GNU General Public License version 2.\n"
50
"Alternatively, this software may be distributed under the terms of the\n"
51
"BSD license. See README and COPYING for more details.\n"
52
#ifdef EAP_TLS_OPENSSL
53
"\nThis product includes software developed by the OpenSSL Project\n"
54
"for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
55
#endif /* EAP_TLS_OPENSSL */
58
#ifndef CONFIG_NO_STDOUT_DEBUG
59
/* Long text divided into parts in order to fit in C89 strings size limits. */
60
const char *wpa_supplicant_full_license1 =
61
"This program is free software; you can redistribute it and/or modify\n"
62
"it under the terms of the GNU General Public License version 2 as\n"
63
"published by the Free Software Foundation.\n"
65
"This program is distributed in the hope that it will be useful,\n"
66
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
67
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
68
"GNU General Public License for more details.\n"
70
const char *wpa_supplicant_full_license2 =
71
"You should have received a copy of the GNU General Public License\n"
72
"along with this program; if not, write to the Free Software\n"
73
"Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
75
"Alternatively, this software may be distributed under the terms of the\n"
78
"Redistribution and use in source and binary forms, with or without\n"
79
"modification, are permitted provided that the following conditions are\n"
82
const char *wpa_supplicant_full_license3 =
83
"1. Redistributions of source code must retain the above copyright\n"
84
" notice, this list of conditions and the following disclaimer.\n"
86
"2. Redistributions in binary form must reproduce the above copyright\n"
87
" notice, this list of conditions and the following disclaimer in the\n"
88
" documentation and/or other materials provided with the distribution.\n"
90
const char *wpa_supplicant_full_license4 =
91
"3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
92
" names of its contributors may be used to endorse or promote products\n"
93
" derived from this software without specific prior written permission.\n"
95
"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
96
"\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
97
"LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
98
"A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
99
const char *wpa_supplicant_full_license5 =
100
"OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
101
"SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
102
"LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
103
"DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
104
"THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
105
"(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
106
"OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
108
#endif /* CONFIG_NO_STDOUT_DEBUG */
110
extern struct wpa_driver_ops *wpa_supplicant_drivers[];
112
extern int wpa_debug_level;
113
extern int wpa_debug_show_keys;
114
extern int wpa_debug_timestamp;
116
/* Configure default/group WEP keys for static WEP */
117
static int wpa_set_wep_keys(struct wpa_supplicant *wpa_s,
118
struct wpa_ssid *ssid)
122
for (i = 0; i < NUM_WEP_KEYS; i++) {
123
if (ssid->wep_key_len[i] == 0)
127
wpa_drv_set_key(wpa_s, WPA_ALG_WEP,
128
(u8 *) "\xff\xff\xff\xff\xff\xff",
129
i, i == ssid->wep_tx_keyidx, (u8 *) "", 0,
130
ssid->wep_key[i], ssid->wep_key_len[i]);
137
static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
138
struct wpa_ssid *ssid)
145
/* IBSS/WPA-None uses only one key (Group) for both receiving and
146
* sending unicast and multicast packets. */
148
if (ssid->mode != IEEE80211_MODE_IBSS) {
149
wpa_printf(MSG_INFO, "WPA: Invalid mode %d (not IBSS/ad-hoc) "
150
"for WPA-None", ssid->mode);
154
if (!ssid->psk_set) {
155
wpa_printf(MSG_INFO, "WPA: No PSK configured for WPA-None");
159
switch (wpa_s->group_cipher) {
160
case WPA_CIPHER_CCMP:
161
os_memcpy(key, ssid->psk, 16);
165
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);
173
wpa_printf(MSG_INFO, "WPA: Invalid group cipher %d for "
174
"WPA-None", wpa_s->group_cipher);
178
/* TODO: should actually remember the previously used seq#, both for TX
179
* and RX from each STA.. */
181
return wpa_drv_set_key(wpa_s, alg, (u8 *) "\xff\xff\xff\xff\xff\xff",
182
0, 1, seq, 6, key, keylen);
186
static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
188
struct wpa_supplicant *wpa_s = eloop_ctx;
189
const u8 *bssid = wpa_s->bssid;
190
if (os_memcmp(bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) == 0)
191
bssid = wpa_s->pending_bssid;
192
wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
194
wpa_blacklist_add(wpa_s, bssid);
195
wpa_sm_notify_disassoc(wpa_s->wpa);
196
wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
197
wpa_s->reassociate = 1;
198
wpa_supplicant_req_scan(wpa_s, 0, 0);
203
* wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
204
* @wpa_s: Pointer to wpa_supplicant data
205
* @sec: Number of seconds after which to time out authentication
206
* @usec: Number of microseconds after which to time out authentication
208
* This function is used to schedule a timeout for the current authentication
211
void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
214
if (wpa_s->conf && wpa_s->conf->ap_scan == 0 &&
215
wpa_s->driver && os_strcmp(wpa_s->driver->name, "wired") == 0)
218
wpa_msg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
219
"%d usec", sec, usec);
220
eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
221
eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
226
* wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
227
* @wpa_s: Pointer to wpa_supplicant data
229
* This function is used to cancel authentication timeout scheduled with
230
* wpa_supplicant_req_auth_timeout() and it is called when authentication has
233
void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
235
wpa_msg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
236
eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
237
wpa_blacklist_del(wpa_s, wpa_s->bssid);
242
* wpa_supplicant_initiate_eapol - Configure EAPOL state machine
243
* @wpa_s: Pointer to wpa_supplicant data
245
* This function is used to configure EAPOL state machine based on the selected
246
* authentication mode.
248
void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
250
#ifdef IEEE8021X_EAPOL
251
struct eapol_config eapol_conf;
252
struct wpa_ssid *ssid = wpa_s->current_ssid;
254
if (wpa_s->key_mgmt == WPA_KEY_MGMT_PSK ||
255
wpa_s->key_mgmt == WPA_KEY_MGMT_FT_PSK) {
256
eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
257
eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
259
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
260
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
261
eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
263
eapol_sm_notify_portControl(wpa_s->eapol, Auto);
265
os_memset(&eapol_conf, 0, sizeof(eapol_conf));
266
if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
267
eapol_conf.accept_802_1x_keys = 1;
268
eapol_conf.required_keys = 0;
269
if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
270
eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
272
if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
273
eapol_conf.required_keys |=
274
EAPOL_REQUIRE_KEY_BROADCAST;
277
if (wpa_s->conf && wpa_s->driver &&
278
os_strcmp(wpa_s->driver->name, "wired") == 0) {
279
eapol_conf.required_keys = 0;
283
eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
284
eapol_conf.workaround = ssid->eap_workaround;
285
eapol_conf.eap_disabled = wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X &&
286
wpa_s->key_mgmt != WPA_KEY_MGMT_FT_IEEE8021X &&
287
wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA;
288
eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
289
#endif /* IEEE8021X_EAPOL */
294
* wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
295
* @wpa_s: Pointer to wpa_supplicant data
296
* @ssid: Configuration data for the network
298
* This function is used to configure WPA state machine and related parameters
299
* to a mode where WPA is not enabled. This is called as part of the
300
* authentication configuration when the selected network does not use WPA.
302
void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
303
struct wpa_ssid *ssid)
307
if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
308
wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
310
wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
311
wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
312
wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
313
wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
314
wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
315
wpa_s->group_cipher = WPA_CIPHER_NONE;
316
wpa_s->mgmt_group_cipher = 0;
318
for (i = 0; i < NUM_WEP_KEYS; i++) {
319
if (ssid->wep_key_len[i] > 5) {
320
wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
321
wpa_s->group_cipher = WPA_CIPHER_WEP104;
323
} else if (ssid->wep_key_len[i] > 0) {
324
wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
325
wpa_s->group_cipher = WPA_CIPHER_WEP40;
330
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
331
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
332
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
333
wpa_s->pairwise_cipher);
334
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
335
#ifdef CONFIG_IEEE80211W
336
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
337
wpa_s->mgmt_group_cipher);
338
#endif /* CONFIG_IEEE80211W */
340
pmksa_cache_clear_current(wpa_s->wpa);
344
static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
346
scard_deinit(wpa_s->scard);
348
wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
349
eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
350
l2_packet_deinit(wpa_s->l2);
353
l2_packet_deinit(wpa_s->l2_br);
357
if (wpa_s->ctrl_iface) {
358
wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
359
wpa_s->ctrl_iface = NULL;
361
if (wpa_s->conf != NULL) {
362
wpa_config_free(wpa_s->conf);
366
os_free(wpa_s->confname);
367
wpa_s->confname = NULL;
369
wpa_sm_set_eapol(wpa_s->wpa, NULL);
370
eapol_sm_deinit(wpa_s->eapol);
373
rsn_preauth_deinit(wpa_s->wpa);
375
pmksa_candidate_free(wpa_s->wpa);
376
wpa_sm_deinit(wpa_s->wpa);
378
wpa_blacklist_clear(wpa_s);
380
wpa_scan_results_free(wpa_s->scan_res);
381
wpa_s->scan_res = NULL;
383
wpa_supplicant_cancel_scan(wpa_s);
384
wpa_supplicant_cancel_auth_timeout(wpa_s);
386
ieee80211_sta_deinit(wpa_s);
391
* wpa_clear_keys - Clear keys configured for the driver
392
* @wpa_s: Pointer to wpa_supplicant data
393
* @addr: Previously used BSSID or %NULL if not available
395
* This function clears the encryption keys that has been previously configured
398
void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
400
u8 *bcast = (u8 *) "\xff\xff\xff\xff\xff\xff";
402
if (wpa_s->keys_cleared) {
403
/* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
404
* timing issues with keys being cleared just before new keys
405
* are set or just after association or something similar. This
406
* shows up in group key handshake failing often because of the
407
* client not receiving the first encrypted packets correctly.
408
* Skipping some of the extra key clearing steps seems to help
409
* in completing group key handshake more reliably. */
410
wpa_printf(MSG_DEBUG, "No keys have been configured - "
411
"skip key clearing");
415
/* MLME-DELETEKEYS.request */
416
wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 0, 0, NULL, 0, NULL, 0);
417
wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 1, 0, NULL, 0, NULL, 0);
418
wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 2, 0, NULL, 0, NULL, 0);
419
wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 3, 0, NULL, 0, NULL, 0);
421
wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
423
/* MLME-SETPROTECTION.request(None) */
424
wpa_drv_mlme_setprotection(
426
MLME_SETPROTECTION_PROTECT_TYPE_NONE,
427
MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
429
wpa_s->keys_cleared = 1;
434
* wpa_supplicant_state_txt - Get the connection state name as a text string
435
* @state: State (wpa_state; WPA_*)
436
* Returns: The state name as a printable text string
438
const char * wpa_supplicant_state_txt(int state)
441
case WPA_DISCONNECTED:
442
return "DISCONNECTED";
447
case WPA_ASSOCIATING:
448
return "ASSOCIATING";
451
case WPA_4WAY_HANDSHAKE:
452
return "4WAY_HANDSHAKE";
453
case WPA_GROUP_HANDSHAKE:
454
return "GROUP_HANDSHAKE";
464
* wpa_supplicant_set_state - Set current connection state
465
* @wpa_s: Pointer to wpa_supplicant data
466
* @state: The new connection state
468
* This function is called whenever the connection state changes, e.g.,
469
* association is completed for WPA/WPA2 4-Way Handshake is started.
471
void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, wpa_states state)
473
wpa_printf(MSG_DEBUG, "State: %s -> %s",
474
wpa_supplicant_state_txt(wpa_s->wpa_state),
475
wpa_supplicant_state_txt(state));
477
wpa_supplicant_dbus_notify_state_change(wpa_s, state,
480
if (state == WPA_COMPLETED && wpa_s->new_connection) {
481
#if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
482
struct wpa_ssid *ssid = wpa_s->current_ssid;
483
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
484
MACSTR " completed %s [id=%d id_str=%s]",
485
MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ?
486
"(reauth)" : "(auth)",
487
ssid ? ssid->id : -1,
488
ssid && ssid->id_str ? ssid->id_str : "");
489
#endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
490
wpa_s->new_connection = 0;
491
wpa_s->reassociated_connection = 1;
492
wpa_drv_set_operstate(wpa_s, 1);
493
} else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
494
state == WPA_ASSOCIATED) {
495
wpa_s->new_connection = 1;
496
wpa_drv_set_operstate(wpa_s, 0);
498
wpa_s->wpa_state = state;
502
static void wpa_supplicant_terminate(int sig, void *eloop_ctx,
505
struct wpa_global *global = eloop_ctx;
506
struct wpa_supplicant *wpa_s;
507
for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
508
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d "
515
static void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
517
wpa_s->pairwise_cipher = 0;
518
wpa_s->group_cipher = 0;
519
wpa_s->mgmt_group_cipher = 0;
521
wpa_s->wpa_state = WPA_DISCONNECTED;
526
* wpa_supplicant_reload_configuration - Reload configuration data
527
* @wpa_s: Pointer to wpa_supplicant data
528
* Returns: 0 on success or -1 if configuration parsing failed
530
* This function can be used to request that the configuration data is reloaded
531
* (e.g., after configuration file change). This function is reloading
532
* configuration only for one interface, so this may need to be called multiple
533
* times if %wpa_supplicant is controlling multiple interfaces and all
534
* interfaces need reconfiguration.
536
int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
538
struct wpa_config *conf;
540
if (wpa_s->confname == NULL)
542
conf = wpa_config_read(wpa_s->confname);
544
wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
545
"file '%s' - exiting", wpa_s->confname);
549
reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
550
|| (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
551
os_strcmp(conf->ctrl_interface,
552
wpa_s->conf->ctrl_interface) != 0);
554
if (reconf_ctrl && wpa_s->ctrl_iface) {
555
wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
556
wpa_s->ctrl_iface = NULL;
559
eapol_sm_invalidate_cached_session(wpa_s->eapol);
560
wpa_s->current_ssid = NULL;
562
* TODO: should notify EAPOL SM about changes in opensc_engine_path,
563
* pkcs11_engine_path, pkcs11_module_path.
565
if (wpa_s->key_mgmt == WPA_KEY_MGMT_PSK ||
566
wpa_s->key_mgmt == WPA_KEY_MGMT_FT_PSK) {
568
* Clear forced success to clear EAP state for next
571
eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
573
eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
574
wpa_sm_set_config(wpa_s->wpa, NULL);
575
wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
576
rsn_preauth_deinit(wpa_s->wpa);
577
wpa_config_free(wpa_s->conf);
580
wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
582
wpa_supplicant_clear_status(wpa_s);
583
wpa_s->reassociate = 1;
584
wpa_supplicant_req_scan(wpa_s, 0, 0);
585
wpa_msg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
590
static void wpa_supplicant_reconfig(int sig, void *eloop_ctx,
593
struct wpa_global *global = eloop_ctx;
594
struct wpa_supplicant *wpa_s;
595
wpa_printf(MSG_DEBUG, "Signal %d received - reconfiguring", sig);
596
for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
597
if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
604
static wpa_cipher cipher_suite2driver(int cipher)
607
case WPA_CIPHER_NONE:
609
case WPA_CIPHER_WEP40:
611
case WPA_CIPHER_WEP104:
612
return CIPHER_WEP104;
613
case WPA_CIPHER_CCMP:
615
case WPA_CIPHER_TKIP:
622
static wpa_key_mgmt key_mgmt2driver(int key_mgmt)
625
case WPA_KEY_MGMT_NONE:
626
return KEY_MGMT_NONE;
627
case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
628
return KEY_MGMT_802_1X_NO_WPA;
629
case WPA_KEY_MGMT_IEEE8021X:
630
return KEY_MGMT_802_1X;
631
case WPA_KEY_MGMT_WPA_NONE:
632
return KEY_MGMT_WPA_NONE;
633
case WPA_KEY_MGMT_FT_IEEE8021X:
634
return KEY_MGMT_FT_802_1X;
635
case WPA_KEY_MGMT_FT_PSK:
636
return KEY_MGMT_FT_PSK;
637
case WPA_KEY_MGMT_PSK:
644
static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
645
struct wpa_ssid *ssid,
646
struct wpa_ie_data *ie)
648
int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
651
wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
652
"from association info");
657
wpa_printf(MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set cipher "
659
if (!(ie->group_cipher & ssid->group_cipher)) {
660
wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
661
"cipher 0x%x (mask 0x%x) - reject",
662
ie->group_cipher, ssid->group_cipher);
665
if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
666
wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
667
"cipher 0x%x (mask 0x%x) - reject",
668
ie->pairwise_cipher, ssid->pairwise_cipher);
671
if (!(ie->key_mgmt & ssid->key_mgmt)) {
672
wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
673
"management 0x%x (mask 0x%x) - reject",
674
ie->key_mgmt, ssid->key_mgmt);
678
#ifdef CONFIG_IEEE80211W
679
if (!(ie->capabilities & WPA_CAPABILITY_MGMT_FRAME_PROTECTION) &&
680
ssid->ieee80211w == IEEE80211W_REQUIRED) {
681
wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
682
"that does not support management frame protection - "
686
#endif /* CONFIG_IEEE80211W */
693
* wpa_supplicant_set_suites - Set authentication and encryption parameters
694
* @wpa_s: Pointer to wpa_supplicant data
695
* @bss: Scan results for the selected BSS, or %NULL if not available
696
* @ssid: Configuration data for the selected network
697
* @wpa_ie: Buffer for the WPA/RSN IE
698
* @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
699
* used buffer length in case the functions returns success.
700
* Returns: 0 on success or -1 on failure
702
* This function is used to configure authentication and encryption parameters
703
* based on the network configuration and scan result for the selected BSS (if
706
int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
707
struct wpa_scan_res *bss,
708
struct wpa_ssid *ssid,
709
u8 *wpa_ie, size_t *wpa_ie_len)
711
struct wpa_ie_data ie;
713
const u8 *bss_wpa, *bss_rsn;
716
bss_wpa = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
717
bss_rsn = wpa_scan_get_ie(bss, WLAN_EID_RSN);
719
bss_wpa = bss_rsn = NULL;
721
if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
722
wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
723
(ie.group_cipher & ssid->group_cipher) &&
724
(ie.pairwise_cipher & ssid->pairwise_cipher) &&
725
(ie.key_mgmt & ssid->key_mgmt)) {
726
wpa_msg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
727
proto = WPA_PROTO_RSN;
728
} else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
729
wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
730
(ie.group_cipher & ssid->group_cipher) &&
731
(ie.pairwise_cipher & ssid->pairwise_cipher) &&
732
(ie.key_mgmt & ssid->key_mgmt)) {
733
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
734
proto = WPA_PROTO_WPA;
736
wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
739
if (ssid->proto & WPA_PROTO_RSN)
740
proto = WPA_PROTO_RSN;
742
proto = WPA_PROTO_WPA;
743
if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
744
os_memset(&ie, 0, sizeof(ie));
745
ie.group_cipher = ssid->group_cipher;
746
ie.pairwise_cipher = ssid->pairwise_cipher;
747
ie.key_mgmt = ssid->key_mgmt;
748
#ifdef CONFIG_IEEE80211W
749
ie.mgmt_group_cipher =
750
ssid->ieee80211w != NO_IEEE80211W ?
751
WPA_CIPHER_AES_128_CMAC : 0;
752
#endif /* CONFIG_IEEE80211W */
753
wpa_printf(MSG_DEBUG, "WPA: Set cipher suites based "
759
wpa_printf(MSG_DEBUG, "WPA: Selected cipher suites: group %d "
760
"pairwise %d key_mgmt %d proto %d",
761
ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
762
#ifdef CONFIG_IEEE80211W
763
if (ssid->ieee80211w) {
764
wpa_printf(MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
765
ie.mgmt_group_cipher);
767
#endif /* CONFIG_IEEE80211W */
769
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
770
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
771
!!(ssid->proto & WPA_PROTO_RSN));
773
if (bss || !wpa_s->ap_ies_from_associnfo) {
774
if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
775
bss_wpa ? 2 + bss_wpa[1] : 0) ||
776
wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
777
bss_rsn ? 2 + bss_rsn[1] : 0))
781
sel = ie.group_cipher & ssid->group_cipher;
782
if (sel & WPA_CIPHER_CCMP) {
783
wpa_s->group_cipher = WPA_CIPHER_CCMP;
784
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP");
785
} else if (sel & WPA_CIPHER_TKIP) {
786
wpa_s->group_cipher = WPA_CIPHER_TKIP;
787
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP");
788
} else if (sel & WPA_CIPHER_WEP104) {
789
wpa_s->group_cipher = WPA_CIPHER_WEP104;
790
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104");
791
} else if (sel & WPA_CIPHER_WEP40) {
792
wpa_s->group_cipher = WPA_CIPHER_WEP40;
793
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40");
795
wpa_printf(MSG_WARNING, "WPA: Failed to select group cipher.");
799
sel = ie.pairwise_cipher & ssid->pairwise_cipher;
800
if (sel & WPA_CIPHER_CCMP) {
801
wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
802
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP");
803
} else if (sel & WPA_CIPHER_TKIP) {
804
wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
805
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP");
806
} else if (sel & WPA_CIPHER_NONE) {
807
wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
808
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE");
810
wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
815
sel = ie.key_mgmt & ssid->key_mgmt;
817
#ifdef CONFIG_IEEE80211R
818
} else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
819
wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
820
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
821
} else if (sel & WPA_KEY_MGMT_FT_PSK) {
822
wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
823
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
824
#endif /* CONFIG_IEEE80211R */
825
} else if (sel & WPA_KEY_MGMT_IEEE8021X) {
826
wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
827
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
828
} else if (sel & WPA_KEY_MGMT_PSK) {
829
wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
830
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
831
} else if (sel & WPA_KEY_MGMT_WPA_NONE) {
832
wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
833
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
835
wpa_printf(MSG_WARNING, "WPA: Failed to select authenticated "
836
"key management type.");
840
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
841
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
842
wpa_s->pairwise_cipher);
843
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
845
#ifdef CONFIG_IEEE80211W
846
sel = ie.mgmt_group_cipher;
847
if (ssid->ieee80211w == NO_IEEE80211W ||
848
!(ie.capabilities & WPA_CAPABILITY_MGMT_FRAME_PROTECTION))
850
if (sel & WPA_CIPHER_AES_128_CMAC) {
851
wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
852
wpa_msg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
855
wpa_s->mgmt_group_cipher = 0;
856
wpa_msg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
858
wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
859
wpa_s->mgmt_group_cipher);
860
#endif /* CONFIG_IEEE80211W */
862
if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
863
wpa_printf(MSG_WARNING, "WPA: Failed to generate WPA IE.");
867
if (ssid->key_mgmt & (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_FT_PSK))
868
wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
870
wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
877
* wpa_supplicant_associate - Request association
878
* @wpa_s: Pointer to wpa_supplicant data
879
* @bss: Scan results for the selected BSS, or %NULL if not available
880
* @ssid: Configuration data for the selected network
882
* This function is used to request %wpa_supplicant to associate with a BSS.
884
void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
885
struct wpa_scan_res *bss, struct wpa_ssid *ssid)
889
int use_crypt, ret, i;
890
int algs = AUTH_ALG_OPEN_SYSTEM;
891
wpa_cipher cipher_pairwise, cipher_group;
892
struct wpa_driver_associate_params params;
893
int wep_keys_set = 0;
894
struct wpa_driver_capa capa;
895
int assoc_failed = 0;
897
wpa_s->reassociate = 0;
899
#ifdef CONFIG_IEEE80211R
901
#endif /* CONFIG_IEEE80211R */
902
const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
903
wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
904
" (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
905
ie ? wpa_ssid_txt(ie + 2, ie[1]) : "", bss->freq);
906
os_memset(wpa_s->bssid, 0, ETH_ALEN);
907
os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
908
#ifdef CONFIG_IEEE80211R
909
ie = wpa_scan_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
910
if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
912
wpa_sm_set_ft_params(wpa_s->wpa, md, NULL, 0, NULL);
913
#endif /* CONFIG_IEEE80211R */
915
wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
916
wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
917
os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
919
wpa_supplicant_cancel_scan(wpa_s);
921
/* Starting new association, so clear the possibly used WPA IE from the
922
* previous association. */
923
wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
925
#ifdef IEEE8021X_EAPOL
926
if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
928
if (ssid->non_leap == 0)
929
algs = AUTH_ALG_LEAP;
931
algs |= AUTH_ALG_LEAP;
934
#endif /* IEEE8021X_EAPOL */
935
wpa_printf(MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
936
if (ssid->auth_alg) {
938
if (ssid->auth_alg & WPA_AUTH_ALG_OPEN)
939
algs |= AUTH_ALG_OPEN_SYSTEM;
940
if (ssid->auth_alg & WPA_AUTH_ALG_SHARED)
941
algs |= AUTH_ALG_SHARED_KEY;
942
if (ssid->auth_alg & WPA_AUTH_ALG_LEAP)
943
algs |= AUTH_ALG_LEAP;
944
wpa_printf(MSG_DEBUG, "Overriding auth_alg selection: 0x%x",
947
wpa_drv_set_auth_alg(wpa_s, algs);
949
if (bss && (wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
950
wpa_scan_get_ie(bss, WLAN_EID_RSN)) &&
951
(ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |
952
WPA_KEY_MGMT_FT_IEEE8021X |
953
WPA_KEY_MGMT_FT_PSK))) {
954
int try_opportunistic;
955
try_opportunistic = ssid->proactive_key_caching &&
956
(ssid->proto & WPA_PROTO_RSN);
957
if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
959
try_opportunistic) == 0)
960
eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
961
wpa_ie_len = sizeof(wpa_ie);
962
if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
963
wpa_ie, &wpa_ie_len)) {
964
wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
965
"management and encryption suites");
968
} else if (ssid->key_mgmt &
969
(WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X |
970
WPA_KEY_MGMT_WPA_NONE | WPA_KEY_MGMT_FT_PSK |
971
WPA_KEY_MGMT_FT_IEEE8021X)) {
972
wpa_ie_len = sizeof(wpa_ie);
973
if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
974
wpa_ie, &wpa_ie_len)) {
975
wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
976
"management and encryption suites (no scan "
981
wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
985
wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
987
cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher);
988
cipher_group = cipher_suite2driver(wpa_s->group_cipher);
989
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
990
wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
991
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
993
if (wpa_set_wep_keys(wpa_s, ssid)) {
999
#ifdef IEEE8021X_EAPOL
1000
if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1001
if ((ssid->eapol_flags &
1002
(EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1003
EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1007
/* Assume that dynamic WEP-104 keys will be used and
1008
* set cipher suites in order for drivers to expect
1010
cipher_pairwise = cipher_group = CIPHER_WEP104;
1013
#endif /* IEEE8021X_EAPOL */
1015
if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1016
/* Set the key before (and later after) association */
1017
wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1020
wpa_drv_set_drop_unencrypted(wpa_s, use_crypt);
1021
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1022
os_memset(¶ms, 0, sizeof(params));
1024
const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
1025
params.bssid = bss->bssid;
1026
params.ssid = ie ? ie + 2 : (u8 *) "";
1027
params.ssid_len = ie ? ie[1] : 0;
1028
params.freq = bss->freq;
1030
params.ssid = ssid->ssid;
1031
params.ssid_len = ssid->ssid_len;
1033
if (ssid->mode == 1 && ssid->frequency > 0 && params.freq == 0)
1034
params.freq = ssid->frequency; /* Initial channel for IBSS */
1035
params.wpa_ie = wpa_ie;
1036
params.wpa_ie_len = wpa_ie_len;
1037
params.pairwise_suite = cipher_pairwise;
1038
params.group_suite = cipher_group;
1039
params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1040
params.auth_alg = algs;
1041
params.mode = ssid->mode;
1042
for (i = 0; i < NUM_WEP_KEYS; i++) {
1043
if (ssid->wep_key_len[i])
1044
params.wep_key[i] = ssid->wep_key[i];
1045
params.wep_key_len[i] = ssid->wep_key_len[i];
1047
params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1049
if (wpa_s->driver_4way_handshake &&
1050
(params.key_mgmt_suite == KEY_MGMT_PSK ||
1051
params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1052
params.passphrase = ssid->passphrase;
1054
params.psk = ssid->psk;
1057
#ifdef CONFIG_IEEE80211W
1058
switch (ssid->ieee80211w) {
1060
params.mgmt_frame_protection = NO_MGMT_FRAME_PROTECTION;
1062
case IEEE80211W_OPTIONAL:
1063
params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_OPTIONAL;
1065
case IEEE80211W_REQUIRED:
1066
params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_REQUIRED;
1069
#endif /* CONFIG_IEEE80211W */
1071
if (wpa_s->use_client_mlme)
1072
ret = ieee80211_sta_associate(wpa_s, ¶ms);
1074
ret = wpa_drv_associate(wpa_s, ¶ms);
1076
wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1078
/* try to continue anyway; new association will be tried again
1083
if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1084
/* Set the key after the association just in case association
1085
* cleared the previously configured key. */
1086
wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1087
/* No need to timeout authentication since there is no key
1089
wpa_supplicant_cancel_auth_timeout(wpa_s);
1090
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1092
/* Timeout for IEEE 802.11 authentication and association */
1096
else if (wpa_s->conf->ap_scan == 1)
1100
wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1103
if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1104
capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1105
/* Set static WEP keys again */
1106
wpa_set_wep_keys(wpa_s, ssid);
1109
if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1111
* Do not allow EAP session resumption between different
1112
* network configurations.
1114
eapol_sm_invalidate_cached_session(wpa_s->eapol);
1116
wpa_s->current_ssid = ssid;
1117
wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1118
wpa_supplicant_initiate_eapol(wpa_s);
1123
* wpa_supplicant_disassociate - Disassociate the current connection
1124
* @wpa_s: Pointer to wpa_supplicant data
1125
* @reason_code: IEEE 802.11 reason code for the disassociate frame
1127
* This function is used to request %wpa_supplicant to disassociate with the
1130
void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1134
if (os_memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 0)
1136
if (wpa_s->use_client_mlme)
1137
ieee80211_sta_disassociate(wpa_s, reason_code);
1139
wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1140
addr = wpa_s->bssid;
1142
wpa_clear_keys(wpa_s, addr);
1143
wpa_supplicant_mark_disassoc(wpa_s);
1144
wpa_s->current_ssid = NULL;
1145
wpa_sm_set_config(wpa_s->wpa, NULL);
1146
eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1151
* wpa_supplicant_deauthenticate - Deauthenticate the current connection
1152
* @wpa_s: Pointer to wpa_supplicant data
1153
* @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1155
* This function is used to request %wpa_supplicant to disassociate with the
1158
void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1162
wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1163
if (os_memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 0)
1165
if (wpa_s->use_client_mlme)
1166
ieee80211_sta_deauthenticate(wpa_s, reason_code);
1168
wpa_drv_deauthenticate(wpa_s, wpa_s->bssid,
1170
addr = wpa_s->bssid;
1172
wpa_clear_keys(wpa_s, addr);
1173
wpa_s->current_ssid = NULL;
1174
wpa_sm_set_config(wpa_s->wpa, NULL);
1175
eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1176
eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1177
eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1181
static int wpa_supplicant_get_scan_results_old(struct wpa_supplicant *wpa_s)
1183
#define SCAN_AP_LIMIT 128
1184
struct wpa_scan_result *results;
1186
struct wpa_scan_results *res;
1188
results = os_malloc(SCAN_AP_LIMIT * sizeof(struct wpa_scan_result));
1189
if (results == NULL) {
1190
wpa_printf(MSG_WARNING, "Failed to allocate memory for scan "
1195
num = wpa_drv_get_scan_results(wpa_s, results, SCAN_AP_LIMIT);
1196
wpa_printf(MSG_DEBUG, "Scan results: %d", num);
1198
wpa_printf(MSG_DEBUG, "Failed to get scan results");
1202
if (num > SCAN_AP_LIMIT) {
1203
wpa_printf(MSG_INFO, "Not enough room for all APs (%d < %d)",
1204
num, SCAN_AP_LIMIT);
1205
num = SCAN_AP_LIMIT;
1208
wpa_scan_results_free(wpa_s->scan_res);
1209
wpa_s->scan_res = NULL;
1211
/* Convert old scan result data structure to the new one */
1212
res = os_zalloc(sizeof(*res));
1217
res->res = os_zalloc(num * sizeof(struct wpa_scan_res *));
1218
if (res->res == NULL) {
1224
for (i = 0; i < num; i++) {
1225
struct wpa_scan_result *bss = &results[i];
1226
struct wpa_scan_res *r;
1230
ie_len = 2 + bss->ssid_len + bss->rsn_ie_len + bss->wpa_ie_len;
1233
if (bss->mdie_present)
1236
r = os_zalloc(sizeof(*r) + ie_len);
1240
os_memcpy(r->bssid, bss->bssid, ETH_ALEN);
1241
r->freq = bss->freq;
1242
r->caps = bss->caps;
1243
r->qual = bss->qual;
1244
r->noise = bss->noise;
1245
r->level = bss->level;
1249
pos = (u8 *) (r + 1);
1252
*pos++ = WLAN_EID_SSID;
1253
*pos++ = bss->ssid_len;
1254
os_memcpy(pos, bss->ssid, bss->ssid_len);
1255
pos += bss->ssid_len;
1258
/* Fake Supported Rate IE to include max rate */
1259
*pos++ = WLAN_EID_SUPP_RATES;
1261
*pos++ = bss->maxrate;
1264
if (bss->rsn_ie_len) {
1265
os_memcpy(pos, bss->rsn_ie, bss->rsn_ie_len);
1266
pos += bss->rsn_ie_len;
1269
if (bss->mdie_present) {
1270
os_memcpy(pos, bss->mdie, 5);
1274
if (bss->wpa_ie_len) {
1275
os_memcpy(pos, bss->wpa_ie, bss->wpa_ie_len);
1276
pos += bss->wpa_ie_len;
1279
res->res[res->num++] = r;
1283
wpa_s->scan_res = res;
1290
* wpa_supplicant_get_scan_results - Get scan results
1291
* @wpa_s: Pointer to wpa_supplicant data
1292
* Returns: 0 on success, -1 on failure
1294
* This function is request the current scan results from the driver and stores
1295
* a local copy of the results in wpa_s->scan_res.
1297
int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s)
1301
if (wpa_s->use_client_mlme) {
1302
wpa_scan_results_free(wpa_s->scan_res);
1303
wpa_s->scan_res = ieee80211_sta_get_scan_results(wpa_s);
1304
if (wpa_s->scan_res == NULL) {
1305
wpa_printf(MSG_DEBUG, "Failed to get scan results");
1309
} else if (wpa_s->driver->get_scan_results2 == NULL)
1310
ret = wpa_supplicant_get_scan_results_old(wpa_s);
1312
wpa_scan_results_free(wpa_s->scan_res);
1313
wpa_s->scan_res = wpa_drv_get_scan_results2(wpa_s);
1314
if (wpa_s->scan_res == NULL) {
1315
wpa_printf(MSG_DEBUG, "Failed to get scan results");
1321
if (wpa_s->scan_res)
1322
wpa_scan_sort_results(wpa_s->scan_res);
1329
* wpa_supplicant_get_ssid - Get a pointer to the current network structure
1330
* @wpa_s: Pointer to wpa_supplicant data
1331
* Returns: A pointer to the current network structure or %NULL on failure
1333
struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
1335
struct wpa_ssid *entry;
1336
u8 ssid[MAX_SSID_LEN];
1342
if (wpa_s->use_client_mlme) {
1343
if (ieee80211_sta_get_ssid(wpa_s, ssid, &ssid_len)) {
1344
wpa_printf(MSG_WARNING, "Could not read SSID from "
1349
res = wpa_drv_get_ssid(wpa_s, ssid);
1351
wpa_printf(MSG_WARNING, "Could not read SSID from "
1358
if (wpa_s->use_client_mlme)
1359
os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
1360
else if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
1361
wpa_printf(MSG_WARNING, "Could not read BSSID from driver.");
1365
wired = wpa_s->conf->ap_scan == 0 && wpa_s->driver &&
1366
os_strcmp(wpa_s->driver->name, "wired") == 0;
1368
entry = wpa_s->conf->ssid;
1370
if (!entry->disabled &&
1371
((ssid_len == entry->ssid_len &&
1372
os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
1373
(!entry->bssid_set ||
1374
os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1376
entry = entry->next;
1383
static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
1391
if (wpa_supplicant_drivers[0] == NULL) {
1392
wpa_printf(MSG_ERROR, "No driver interfaces build into "
1398
/* default to first driver in the list */
1399
wpa_s->driver = wpa_supplicant_drivers[0];
1403
for (i = 0; wpa_supplicant_drivers[i]; i++) {
1404
if (os_strcmp(name, wpa_supplicant_drivers[i]->name) == 0) {
1405
wpa_s->driver = wpa_supplicant_drivers[i];
1410
wpa_printf(MSG_ERROR, "Unsupported driver '%s'.\n", name);
1415
void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1416
const u8 *buf, size_t len)
1418
struct wpa_supplicant *wpa_s = ctx;
1420
wpa_printf(MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
1421
wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
1423
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
1424
wpa_printf(MSG_DEBUG, "Ignored received EAPOL frame since "
1425
"no key management is configured");
1429
if (wpa_s->eapol_received == 0 &&
1430
(!wpa_s->driver_4way_handshake ||
1431
(wpa_s->key_mgmt != WPA_KEY_MGMT_PSK &&
1432
wpa_s->key_mgmt != WPA_KEY_MGMT_FT_PSK) ||
1433
wpa_s->wpa_state != WPA_COMPLETED)) {
1434
/* Timeout for completing IEEE 802.1X and WPA authentication */
1435
wpa_supplicant_req_auth_timeout(
1437
(wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
1438
wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
1439
wpa_s->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X) ?
1442
wpa_s->eapol_received++;
1444
if (wpa_s->countermeasures) {
1445
wpa_printf(MSG_INFO, "WPA: Countermeasures - dropped EAPOL "
1450
/* Source address of the incoming EAPOL frame could be compared to the
1451
* current BSSID. However, it is possible that a centralized
1452
* Authenticator could be using another MAC address than the BSSID of
1453
* an AP, so just allow any address to be used for now. The replies are
1454
* still sent to the current BSSID (if available), though. */
1456
os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
1457
if (wpa_s->key_mgmt != WPA_KEY_MGMT_PSK &&
1458
wpa_s->key_mgmt != WPA_KEY_MGMT_FT_PSK &&
1459
eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
1461
wpa_drv_poll(wpa_s);
1462
if (!wpa_s->driver_4way_handshake)
1463
wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
1464
else if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
1465
wpa_s->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X) {
1467
* Set portValid = TRUE here since we are going to skip 4-way
1468
* handshake processing which would normally set portValid. We
1469
* need this to allow the EAPOL state machines to be completed
1470
* without going through EAPOL-Key handshake.
1472
eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1477
void wpa_supplicant_sta_free_hw_features(struct wpa_hw_modes *hw_features,
1478
size_t num_hw_features)
1480
ieee80211_sta_free_hw_features(hw_features, num_hw_features);
1484
void wpa_supplicant_sta_rx(void *ctx, const u8 *buf, size_t len,
1485
struct ieee80211_rx_status *rx_status)
1487
struct wpa_supplicant *wpa_s = ctx;
1488
ieee80211_sta_rx(wpa_s, buf, len, rx_status);
1493
* wpa_supplicant_driver_init - Initialize driver interface parameters
1494
* @wpa_s: Pointer to wpa_supplicant data
1495
* Returns: 0 on success, -1 on failure
1497
* This function is called to initialize driver interface parameters.
1498
* wpa_drv_init() must have been called before this function to initialize the
1501
int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
1503
static int interface_count = 0;
1505
if (wpa_s->driver->send_eapol) {
1506
const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
1508
os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
1510
wpa_s->l2 = l2_packet_init(wpa_s->ifname,
1511
wpa_drv_get_mac_addr(wpa_s),
1513
wpa_supplicant_rx_eapol, wpa_s, 0);
1514
if (wpa_s->l2 == NULL)
1518
if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
1519
wpa_printf(MSG_ERROR, "Failed to get own L2 address");
1523
wpa_printf(MSG_DEBUG, "Own MAC address: " MACSTR,
1524
MAC2STR(wpa_s->own_addr));
1526
if (wpa_s->bridge_ifname[0]) {
1527
wpa_printf(MSG_DEBUG, "Receiving packets from bridge interface"
1528
" '%s'", wpa_s->bridge_ifname);
1529
wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
1532
wpa_supplicant_rx_eapol, wpa_s,
1534
if (wpa_s->l2_br == NULL) {
1535
wpa_printf(MSG_ERROR, "Failed to open l2_packet "
1536
"connection for the bridge interface '%s'",
1537
wpa_s->bridge_ifname);
1542
/* Backwards compatibility call to set_wpa() handler. This is called
1543
* only just after init and just before deinit, so these handler can be
1544
* used to implement same functionality. */
1545
if (wpa_drv_set_wpa(wpa_s, 1) < 0) {
1546
struct wpa_driver_capa capa;
1547
if (wpa_drv_get_capa(wpa_s, &capa) < 0 ||
1548
!(capa.flags & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1549
WPA_DRIVER_CAPA_KEY_MGMT_WPA2))) {
1550
wpa_printf(MSG_DEBUG, "Driver does not support WPA.");
1551
/* Continue to allow non-WPA modes to be used. */
1553
wpa_printf(MSG_ERROR, "Failed to enable WPA in the "
1559
wpa_clear_keys(wpa_s, NULL);
1561
/* Make sure that TKIP countermeasures are not left enabled (could
1562
* happen if wpa_supplicant is killed during countermeasures. */
1563
wpa_drv_set_countermeasures(wpa_s, 0);
1565
wpa_drv_set_drop_unencrypted(wpa_s, 1);
1567
wpa_printf(MSG_DEBUG, "RSN: flushing PMKID list in the driver");
1568
wpa_drv_flush_pmkid(wpa_s);
1570
wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN;
1571
wpa_supplicant_req_scan(wpa_s, interface_count, 100000);
1578
static int wpa_supplicant_daemon(const char *pid_file)
1580
wpa_printf(MSG_DEBUG, "Daemonize..");
1581
return os_daemonize(pid_file);
1585
static struct wpa_supplicant * wpa_supplicant_alloc(void)
1587
struct wpa_supplicant *wpa_s;
1589
wpa_s = os_zalloc(sizeof(*wpa_s));
1592
wpa_s->scan_req = 1;
1598
static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
1599
struct wpa_interface *iface)
1601
wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
1602
"'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
1603
iface->confname ? iface->confname : "N/A",
1604
iface->driver ? iface->driver : "default",
1605
iface->ctrl_interface ? iface->ctrl_interface : "N/A",
1606
iface->bridge_ifname ? iface->bridge_ifname : "N/A");
1608
if (wpa_supplicant_set_driver(wpa_s, iface->driver) < 0) {
1612
if (iface->confname) {
1613
#ifdef CONFIG_BACKEND_FILE
1614
wpa_s->confname = os_rel2abs_path(iface->confname);
1615
if (wpa_s->confname == NULL) {
1616
wpa_printf(MSG_ERROR, "Failed to get absolute path "
1617
"for configuration file '%s'.",
1621
wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
1622
iface->confname, wpa_s->confname);
1623
#else /* CONFIG_BACKEND_FILE */
1624
wpa_s->confname = os_strdup(iface->confname);
1625
#endif /* CONFIG_BACKEND_FILE */
1626
wpa_s->conf = wpa_config_read(wpa_s->confname);
1627
if (wpa_s->conf == NULL) {
1628
wpa_printf(MSG_ERROR, "Failed to read or parse "
1629
"configuration '%s'.", wpa_s->confname);
1634
* Override ctrl_interface and driver_param if set on command
1637
if (iface->ctrl_interface) {
1638
os_free(wpa_s->conf->ctrl_interface);
1639
wpa_s->conf->ctrl_interface =
1640
os_strdup(iface->ctrl_interface);
1643
if (iface->driver_param) {
1644
os_free(wpa_s->conf->driver_param);
1645
wpa_s->conf->driver_param =
1646
os_strdup(iface->driver_param);
1649
wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
1650
iface->driver_param);
1652
if (wpa_s->conf == NULL) {
1653
wpa_printf(MSG_ERROR, "\nNo configuration found.");
1657
if (iface->ifname == NULL) {
1658
wpa_printf(MSG_ERROR, "\nInterface name is required.");
1661
if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
1662
wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
1666
os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
1668
if (iface->bridge_ifname) {
1669
if (os_strlen(iface->bridge_ifname) >=
1670
sizeof(wpa_s->bridge_ifname)) {
1671
wpa_printf(MSG_ERROR, "\nToo long bridge interface "
1672
"name '%s'.", iface->bridge_ifname);
1675
os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
1676
sizeof(wpa_s->bridge_ifname));
1683
static int wpa_supplicant_init_iface2(struct wpa_supplicant *wpa_s)
1686
struct wpa_driver_capa capa;
1688
wpa_printf(MSG_DEBUG, "Initializing interface (2) '%s'",
1691
/* RSNA Supplicant Key Management - INITIALIZE */
1692
eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1693
eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1695
/* Initialize driver interface and register driver event handler before
1696
* L2 receive handler so that association events are processed before
1697
* EAPOL-Key packets if both become available for the same select()
1699
wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
1700
if (wpa_s->drv_priv == NULL) {
1701
wpa_printf(MSG_ERROR, "Failed to initialize driver interface");
1704
if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
1705
wpa_printf(MSG_ERROR, "Driver interface rejected "
1706
"driver_param '%s'", wpa_s->conf->driver_param);
1710
ifname = wpa_drv_get_ifname(wpa_s);
1711
if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
1712
wpa_printf(MSG_DEBUG, "Driver interface replaced interface "
1713
"name with '%s'", ifname);
1714
os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
1717
if (wpa_supplicant_init_wpa(wpa_s) < 0)
1720
wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
1721
wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
1723
wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1725
if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
1726
wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
1727
wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
1728
wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1729
"dot11RSNAConfigPMKLifetime");
1733
if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
1734
wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
1735
wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
1736
wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1737
"dot11RSNAConfigPMKReauthThreshold");
1741
if (wpa_s->conf->dot11RSNAConfigSATimeout &&
1742
wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
1743
wpa_s->conf->dot11RSNAConfigSATimeout)) {
1744
wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1745
"dot11RSNAConfigSATimeout");
1749
if (wpa_supplicant_driver_init(wpa_s) < 0)
1752
wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
1754
if (wpa_supplicant_init_eapol(wpa_s) < 0)
1756
wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
1758
wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
1759
if (wpa_s->ctrl_iface == NULL) {
1760
wpa_printf(MSG_ERROR,
1761
"Failed to initialize control interface '%s'.\n"
1762
"You may have another wpa_supplicant process "
1763
"already running or the file was\n"
1764
"left by an unclean termination of wpa_supplicant "
1765
"in which case you will need\n"
1766
"to manually remove this file before starting "
1767
"wpa_supplicant again.\n",
1768
wpa_s->conf->ctrl_interface);
1772
if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
1773
if (capa.flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
1774
wpa_s->use_client_mlme = 1;
1775
if (ieee80211_sta_init(wpa_s))
1778
if (capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE)
1779
wpa_s->driver_4way_handshake = 1;
1786
static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s)
1788
if (wpa_s->drv_priv) {
1789
wpa_supplicant_deauthenticate(wpa_s,
1790
WLAN_REASON_DEAUTH_LEAVING);
1792
/* Backwards compatibility call to set_wpa() handler. This is
1793
* called only just after init and just before deinit, so these
1794
* handler can be used to implement same functionality. */
1795
if (wpa_drv_set_wpa(wpa_s, 0) < 0) {
1796
wpa_printf(MSG_ERROR, "Failed to disable WPA in the "
1800
wpa_drv_set_drop_unencrypted(wpa_s, 0);
1801
wpa_drv_set_countermeasures(wpa_s, 0);
1802
wpa_clear_keys(wpa_s, NULL);
1805
wpas_dbus_unregister_iface(wpa_s);
1807
wpa_supplicant_cleanup(wpa_s);
1809
if (wpa_s->drv_priv)
1810
wpa_drv_deinit(wpa_s);
1815
* wpa_supplicant_add_iface - Add a new network interface
1816
* @global: Pointer to global data from wpa_supplicant_init()
1817
* @iface: Interface configuration options
1818
* Returns: Pointer to the created interface or %NULL on failure
1820
* This function is used to add new network interfaces for %wpa_supplicant.
1821
* This can be called before wpa_supplicant_run() to add interfaces before the
1822
* main event loop has been started. In addition, new interfaces can be added
1823
* dynamically while %wpa_supplicant is already running. This could happen,
1824
* e.g., when a hotplug network adapter is inserted.
1826
struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
1827
struct wpa_interface *iface)
1829
struct wpa_supplicant *wpa_s;
1831
if (global == NULL || iface == NULL)
1834
wpa_s = wpa_supplicant_alloc();
1838
if (wpa_supplicant_init_iface(wpa_s, iface) ||
1839
wpa_supplicant_init_iface2(wpa_s)) {
1840
wpa_printf(MSG_DEBUG, "Failed to add interface %s",
1842
wpa_supplicant_deinit_iface(wpa_s);
1847
wpa_s->global = global;
1849
/* Register the interface with the dbus control interface */
1850
if (wpas_dbus_register_iface(wpa_s)) {
1851
wpa_supplicant_deinit_iface(wpa_s);
1856
wpa_s->next = global->ifaces;
1857
global->ifaces = wpa_s;
1859
wpa_printf(MSG_DEBUG, "Added interface %s", wpa_s->ifname);
1866
* wpa_supplicant_remove_iface - Remove a network interface
1867
* @global: Pointer to global data from wpa_supplicant_init()
1868
* @wpa_s: Pointer to the network interface to be removed
1869
* Returns: 0 if interface was removed, -1 if interface was not found
1871
* This function can be used to dynamically remove network interfaces from
1872
* %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
1873
* addition, this function is used to remove all remaining interfaces when
1874
* %wpa_supplicant is terminated.
1876
int wpa_supplicant_remove_iface(struct wpa_global *global,
1877
struct wpa_supplicant *wpa_s)
1879
struct wpa_supplicant *prev;
1881
/* Remove interface from the global list of interfaces */
1882
prev = global->ifaces;
1883
if (prev == wpa_s) {
1884
global->ifaces = wpa_s->next;
1886
while (prev && prev->next != wpa_s)
1890
prev->next = wpa_s->next;
1893
wpa_printf(MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
1895
wpa_supplicant_deinit_iface(wpa_s);
1903
* wpa_supplicant_get_iface - Get a new network interface
1904
* @global: Pointer to global data from wpa_supplicant_init()
1905
* @ifname: Interface name
1906
* Returns: Pointer to the interface or %NULL if not found
1908
struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
1911
struct wpa_supplicant *wpa_s;
1913
for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1914
if (os_strcmp(wpa_s->ifname, ifname) == 0)
1922
* wpa_supplicant_init - Initialize %wpa_supplicant
1923
* @params: Parameters for %wpa_supplicant
1924
* Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
1926
* This function is used to initialize %wpa_supplicant. After successful
1927
* initialization, the returned data pointer can be used to add and remove
1928
* network interfaces, and eventually, to deinitialize %wpa_supplicant.
1930
struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
1932
struct wpa_global *global;
1938
wpa_debug_open_file(params->wpa_debug_file_path);
1940
ret = eap_peer_register_methods();
1942
wpa_printf(MSG_ERROR, "Failed to register EAP methods");
1944
wpa_printf(MSG_ERROR, "Two or more EAP methods used "
1945
"the same EAP type.");
1949
global = os_zalloc(sizeof(*global));
1952
global->params.daemonize = params->daemonize;
1953
global->params.wait_for_monitor = params->wait_for_monitor;
1954
global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
1955
if (params->pid_file)
1956
global->params.pid_file = os_strdup(params->pid_file);
1957
if (params->ctrl_interface)
1958
global->params.ctrl_interface =
1959
os_strdup(params->ctrl_interface);
1960
wpa_debug_level = global->params.wpa_debug_level =
1961
params->wpa_debug_level;
1962
wpa_debug_show_keys = global->params.wpa_debug_show_keys =
1963
params->wpa_debug_show_keys;
1964
wpa_debug_timestamp = global->params.wpa_debug_timestamp =
1965
params->wpa_debug_timestamp;
1967
if (eloop_init(global)) {
1968
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1969
wpa_supplicant_deinit(global);
1973
global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
1974
if (global->ctrl_iface == NULL) {
1975
wpa_supplicant_deinit(global);
1979
if (global->params.dbus_ctrl_interface) {
1980
global->dbus_ctrl_iface =
1981
wpa_supplicant_dbus_ctrl_iface_init(global);
1982
if (global->dbus_ctrl_iface == NULL) {
1983
wpa_supplicant_deinit(global);
1993
* wpa_supplicant_run - Run the %wpa_supplicant main event loop
1994
* @global: Pointer to global data from wpa_supplicant_init()
1995
* Returns: 0 after successful event loop run, -1 on failure
1997
* This function starts the main event loop and continues running as long as
1998
* there are any remaining events. In most cases, this function is running as
1999
* long as the %wpa_supplicant process in still in use.
2001
int wpa_supplicant_run(struct wpa_global *global)
2003
struct wpa_supplicant *wpa_s;
2005
if (global->params.daemonize &&
2006
wpa_supplicant_daemon(global->params.pid_file))
2009
if (global->params.wait_for_monitor) {
2010
for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
2011
if (wpa_s->ctrl_iface)
2012
wpa_supplicant_ctrl_iface_wait(
2016
eloop_register_signal_terminate(wpa_supplicant_terminate, NULL);
2017
eloop_register_signal_reconfig(wpa_supplicant_reconfig, NULL);
2026
* wpa_supplicant_deinit - Deinitialize %wpa_supplicant
2027
* @global: Pointer to global data from wpa_supplicant_init()
2029
* This function is called to deinitialize %wpa_supplicant and to free all
2030
* allocated resources. Remaining network interfaces will also be removed.
2032
void wpa_supplicant_deinit(struct wpa_global *global)
2037
while (global->ifaces)
2038
wpa_supplicant_remove_iface(global, global->ifaces);
2040
if (global->ctrl_iface)
2041
wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
2042
if (global->dbus_ctrl_iface)
2043
wpa_supplicant_dbus_ctrl_iface_deinit(global->dbus_ctrl_iface);
2045
eap_peer_unregister_methods();
2049
if (global->params.pid_file) {
2050
os_daemonize_terminate(global->params.pid_file);
2051
os_free(global->params.pid_file);
2053
os_free(global->params.ctrl_interface);
2056
wpa_debug_close_file();
added
removed
wpa_supplicant/wpa_supplicant.c
