]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/wpa_supplicant.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Re-initialize hostapd/wpa_supplicant git repository based on 0.6.3 release
[thirdparty/hostap.git] / wpa_supplicant / wpa_supplicant.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant
3 * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
4 *
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.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 *
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.
17 */
18
19#include "includes.h"
20
21#include "common.h"
22#include "eapol_supp/eapol_supp_sm.h"
23#include "eap_peer/eap.h"
24#include "wpa.h"
25#include "eloop.h"
26#include "drivers/driver.h"
27#include "config.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"
33#include "version.h"
34#include "preauth.h"
35#include "pmksa_cache.h"
36#include "wpa_ctrl.h"
37#include "mlme.h"
38#include "ieee802_11_defs.h"
39#include "blacklist.h"
40#include "wpas_glue.h"
41
42const char *wpa_supplicant_version =
43"wpa_supplicant v" VERSION_STR "\n"
44"Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi> and contributors";
45
46const 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"
49"\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 */
56;
57
58#ifndef CONFIG_NO_STDOUT_DEBUG
59/* Long text divided into parts in order to fit in C89 strings size limits. */
60const 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"
64"\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"
69"\n";
70const 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"
74"\n"
75"Alternatively, this software may be distributed under the terms of the\n"
76"BSD license.\n"
77"\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"
80"met:\n"
81"\n";
82const 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"
85"\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"
89"\n";
90const 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"
94"\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";
99const 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"
107"\n";
108#endif /* CONFIG_NO_STDOUT_DEBUG */
109
110extern struct wpa_driver_ops *wpa_supplicant_drivers[];
111
112extern int wpa_debug_level;
113extern int wpa_debug_show_keys;
114extern int wpa_debug_timestamp;
115
116/* Configure default/group WEP keys for static WEP */
117static int wpa_set_wep_keys(struct wpa_supplicant *wpa_s,
118 struct wpa_ssid *ssid)
119{
120 int i, set = 0;
121
122 for (i = 0; i < NUM_WEP_KEYS; i++) {
123 if (ssid->wep_key_len[i] == 0)
124 continue;
125
126 set = 1;
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]);
131 }
132
133 return set;
134}
135
136
137static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
138 struct wpa_ssid *ssid)
139{
140 u8 key[32];
141 size_t keylen;
142 wpa_alg alg;
143 u8 seq[6] = { 0 };
144
145 /* IBSS/WPA-None uses only one key (Group) for both receiving and
146 * sending unicast and multicast packets. */
147
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);
151 return -1;
152 }
153
154 if (!ssid->psk_set) {
155 wpa_printf(MSG_INFO, "WPA: No PSK configured for WPA-None");
156 return -1;
157 }
158
159 switch (wpa_s->group_cipher) {
160 case WPA_CIPHER_CCMP:
161 os_memcpy(key, ssid->psk, 16);
162 keylen = 16;
163 alg = WPA_ALG_CCMP;
164 break;
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);
169 keylen = 32;
170 alg = WPA_ALG_TKIP;
171 break;
172 default:
173 wpa_printf(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, (u8 *) "\xff\xff\xff\xff\xff\xff",
182 0, 1, seq, 6, key, keylen);
183}
184
185
186static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
187{
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.",
193 MAC2STR(bssid));
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);
199}
200
201
202/**
203 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
204 * @wpa_s: Pointer to wpa_supplicant data
205 * @sec: Number of seconds after which to time out authentication
206 * @usec: Number of microseconds after which to time out authentication
207 *
208 * This function is used to schedule a timeout for the current authentication
209 * attempt.
210 */
211void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
212 int sec, int usec)
213{
214 if (wpa_s->conf && wpa_s->conf->ap_scan == 0 &&
215 wpa_s->driver && os_strcmp(wpa_s->driver->name, "wired") == 0)
216 return;
217
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);
222}
223
224
225/**
226 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
227 * @wpa_s: Pointer to wpa_supplicant data
228 *
229 * This function is used to cancel authentication timeout scheduled with
230 * wpa_supplicant_req_auth_timeout() and it is called when authentication has
231 * been completed.
232 */
233void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
234{
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);
238}
239
240
241/**
242 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
243 * @wpa_s: Pointer to wpa_supplicant data
244 *
245 * This function is used to configure EAPOL state machine based on the selected
246 * authentication mode.
247 */
248void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
249{
250#ifdef IEEE8021X_EAPOL
251 struct eapol_config eapol_conf;
252 struct wpa_ssid *ssid = wpa_s->current_ssid;
253
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);
258 }
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);
262 else
263 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
264
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;
271 }
272 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
273 eapol_conf.required_keys |=
274 EAPOL_REQUIRE_KEY_BROADCAST;
275 }
276
277 if (wpa_s->conf && wpa_s->driver &&
278 os_strcmp(wpa_s->driver->name, "wired") == 0) {
279 eapol_conf.required_keys = 0;
280 }
281 }
282 if (wpa_s->conf)
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 */
290}
291
292
293/**
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
297 *
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.
301 */
302void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
303 struct wpa_ssid *ssid)
304{
305 int i;
306
307 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
308 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
309 else
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;
317
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;
322 break;
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;
326 break;
327 }
328 }
329
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 */
339
340 pmksa_cache_clear_current(wpa_s->wpa);
341}
342
343
344static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
345{
346 scard_deinit(wpa_s->scard);
347 wpa_s->scard = NULL;
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);
351 wpa_s->l2 = NULL;
352 if (wpa_s->l2_br) {
353 l2_packet_deinit(wpa_s->l2_br);
354 wpa_s->l2_br = NULL;
355 }
356
357 if (wpa_s->ctrl_iface) {
358 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
359 wpa_s->ctrl_iface = NULL;
360 }
361 if (wpa_s->conf != NULL) {
362 wpa_config_free(wpa_s->conf);
363 wpa_s->conf = NULL;
364 }
365
366 os_free(wpa_s->confname);
367 wpa_s->confname = NULL;
368
369 wpa_sm_set_eapol(wpa_s->wpa, NULL);
370 eapol_sm_deinit(wpa_s->eapol);
371 wpa_s->eapol = NULL;
372
373 rsn_preauth_deinit(wpa_s->wpa);
374
375 pmksa_candidate_free(wpa_s->wpa);
376 wpa_sm_deinit(wpa_s->wpa);
377 wpa_s->wpa = NULL;
378 wpa_blacklist_clear(wpa_s);
379
380 wpa_scan_results_free(wpa_s->scan_res);
381 wpa_s->scan_res = NULL;
382
383 wpa_supplicant_cancel_scan(wpa_s);
384 wpa_supplicant_cancel_auth_timeout(wpa_s);
385
386 ieee80211_sta_deinit(wpa_s);
387}
388
389
390/**
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
394 *
395 * This function clears the encryption keys that has been previously configured
396 * for the driver.
397 */
398void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
399{
400 u8 *bcast = (u8 *) "\xff\xff\xff\xff\xff\xff";
401
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");
412 return;
413 }
414
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);
420 if (addr) {
421 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
422 0);
423 /* MLME-SETPROTECTION.request(None) */
424 wpa_drv_mlme_setprotection(
425 wpa_s, addr,
426 MLME_SETPROTECTION_PROTECT_TYPE_NONE,
427 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
428 }
429 wpa_s->keys_cleared = 1;
430}
431
432
433/**
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
437 */
438const char * wpa_supplicant_state_txt(int state)
439{
440 switch (state) {
441 case WPA_DISCONNECTED:
442 return "DISCONNECTED";
443 case WPA_INACTIVE:
444 return "INACTIVE";
445 case WPA_SCANNING:
446 return "SCANNING";
447 case WPA_ASSOCIATING:
448 return "ASSOCIATING";
449 case WPA_ASSOCIATED:
450 return "ASSOCIATED";
451 case WPA_4WAY_HANDSHAKE:
452 return "4WAY_HANDSHAKE";
453 case WPA_GROUP_HANDSHAKE:
454 return "GROUP_HANDSHAKE";
455 case WPA_COMPLETED:
456 return "COMPLETED";
457 default:
458 return "UNKNOWN";
459 }
460}
461
462
463/**
464 * wpa_supplicant_set_state - Set current connection state
465 * @wpa_s: Pointer to wpa_supplicant data
466 * @state: The new connection state
467 *
468 * This function is called whenever the connection state changes, e.g.,
469 * association is completed for WPA/WPA2 4-Way Handshake is started.
470 */
471void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, wpa_states state)
472{
473 wpa_printf(MSG_DEBUG, "State: %s -> %s",
474 wpa_supplicant_state_txt(wpa_s->wpa_state),
475 wpa_supplicant_state_txt(state));
476
477 wpa_supplicant_dbus_notify_state_change(wpa_s, state,
478 wpa_s->wpa_state);
479
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);
497 }
498 wpa_s->wpa_state = state;
499}
500
501
502static void wpa_supplicant_terminate(int sig, void *eloop_ctx,
503 void *signal_ctx)
504{
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 "
509 "received", sig);
510 }
511 eloop_terminate();
512}
513
514
515static void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
516{
517 wpa_s->pairwise_cipher = 0;
518 wpa_s->group_cipher = 0;
519 wpa_s->mgmt_group_cipher = 0;
520 wpa_s->key_mgmt = 0;
521 wpa_s->wpa_state = WPA_DISCONNECTED;
522}
523
524
525/**
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
529 *
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.
535 */
536int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
537{
538 struct wpa_config *conf;
539 int reconf_ctrl;
540 if (wpa_s->confname == NULL)
541 return -1;
542 conf = wpa_config_read(wpa_s->confname);
543 if (conf == NULL) {
544 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
545 "file '%s' - exiting", wpa_s->confname);
546 return -1;
547 }
548
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);
553
554 if (reconf_ctrl && wpa_s->ctrl_iface) {
555 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
556 wpa_s->ctrl_iface = NULL;
557 }
558
559 eapol_sm_invalidate_cached_session(wpa_s->eapol);
560 wpa_s->current_ssid = NULL;
561 /*
562 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
563 * pkcs11_engine_path, pkcs11_module_path.
564 */
565 if (wpa_s->key_mgmt == WPA_KEY_MGMT_PSK ||
566 wpa_s->key_mgmt == WPA_KEY_MGMT_FT_PSK) {
567 /*
568 * Clear forced success to clear EAP state for next
569 * authentication.
570 */
571 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
572 }
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);
578 wpa_s->conf = conf;
579 if (reconf_ctrl)
580 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
581
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");
586 return 0;
587}
588
589
590static void wpa_supplicant_reconfig(int sig, void *eloop_ctx,
591 void *signal_ctx)
592{
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) {
598 eloop_terminate();
599 }
600 }
601}
602
603
604static wpa_cipher cipher_suite2driver(int cipher)
605{
606 switch (cipher) {
607 case WPA_CIPHER_NONE:
608 return CIPHER_NONE;
609 case WPA_CIPHER_WEP40:
610 return CIPHER_WEP40;
611 case WPA_CIPHER_WEP104:
612 return CIPHER_WEP104;
613 case WPA_CIPHER_CCMP:
614 return CIPHER_CCMP;
615 case WPA_CIPHER_TKIP:
616 default:
617 return CIPHER_TKIP;
618 }
619}
620
621
622static wpa_key_mgmt key_mgmt2driver(int key_mgmt)
623{
624 switch (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:
638 default:
639 return KEY_MGMT_PSK;
640 }
641}
642
643
644static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
645 struct wpa_ssid *ssid,
646 struct wpa_ie_data *ie)
647{
648 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
649 if (ret) {
650 if (ret == -2) {
651 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
652 "from association info");
653 }
654 return -1;
655 }
656
657 wpa_printf(MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set cipher "
658 "suites");
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);
663 return -1;
664 }
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);
669 return -1;
670 }
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);
675 return -1;
676 }
677
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 - "
683 "reject");
684 return -1;
685 }
686#endif /* CONFIG_IEEE80211W */
687
688 return 0;
689}
690
691
692/**
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
701 *
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
704 * available).
705 */
706int 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)
710{
711 struct wpa_ie_data ie;
712 int sel, proto;
713 const u8 *bss_wpa, *bss_rsn;
714
715 if (bss) {
716 bss_wpa = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
717 bss_rsn = wpa_scan_get_ie(bss, WLAN_EID_RSN);
718 } else
719 bss_wpa = bss_rsn = NULL;
720
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;
735 } else if (bss) {
736 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
737 return -1;
738 } else {
739 if (ssid->proto & WPA_PROTO_RSN)
740 proto = WPA_PROTO_RSN;
741 else
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 "
754 "on configuration");
755 } else
756 proto = ie.proto;
757 }
758
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);
766 }
767#endif /* CONFIG_IEEE80211W */
768
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));
772
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))
778 return -1;
779 }
780
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");
794 } else {
795 wpa_printf(MSG_WARNING, "WPA: Failed to select group cipher.");
796 return -1;
797 }
798
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");
809 } else {
810 wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
811 "cipher.");
812 return -1;
813 }
814
815 sel = ie.key_mgmt & ssid->key_mgmt;
816 if (0) {
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");
834 } else {
835 wpa_printf(MSG_WARNING, "WPA: Failed to select authenticated "
836 "key management type.");
837 return -1;
838 }
839
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);
844
845#ifdef CONFIG_IEEE80211W
846 sel = ie.mgmt_group_cipher;
847 if (ssid->ieee80211w == NO_IEEE80211W ||
848 !(ie.capabilities & WPA_CAPABILITY_MGMT_FRAME_PROTECTION))
849 sel = 0;
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 "
853 "AES-128-CMAC");
854 } else {
855 wpa_s->mgmt_group_cipher = 0;
856 wpa_msg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
857 }
858 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
859 wpa_s->mgmt_group_cipher);
860#endif /* CONFIG_IEEE80211W */
861
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.");
864 return -1;
865 }
866
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);
869 else
870 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
871
872 return 0;
873}
874
875
876/**
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
881 *
882 * This function is used to request %wpa_supplicant to associate with a BSS.
883 */
884void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
885 struct wpa_scan_res *bss, struct wpa_ssid *ssid)
886{
887 u8 wpa_ie[80];
888 size_t wpa_ie_len;
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;
896
897 wpa_s->reassociate = 0;
898 if (bss) {
899#ifdef CONFIG_IEEE80211R
900 const u8 *md = NULL;
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)
911 md = ie + 2;
912 wpa_sm_set_ft_params(wpa_s->wpa, md, NULL, 0, NULL);
913#endif /* CONFIG_IEEE80211R */
914 } else {
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);
918 }
919 wpa_supplicant_cancel_scan(wpa_s);
920
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);
924
925#ifdef IEEE8021X_EAPOL
926 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
927 if (ssid->leap) {
928 if (ssid->non_leap == 0)
929 algs = AUTH_ALG_LEAP;
930 else
931 algs |= AUTH_ALG_LEAP;
932 }
933 }
934#endif /* IEEE8021X_EAPOL */
935 wpa_printf(MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
936 if (ssid->auth_alg) {
937 algs = 0;
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",
945 algs);
946 }
947 wpa_drv_set_auth_alg(wpa_s, algs);
948
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,
958 wpa_s->current_ssid,
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");
966 return;
967 }
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 "
977 "results)");
978 return;
979 }
980 } else {
981 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
982 wpa_ie_len = 0;
983 }
984
985 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
986 use_crypt = 1;
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)
992 use_crypt = 0;
993 if (wpa_set_wep_keys(wpa_s, ssid)) {
994 use_crypt = 1;
995 wep_keys_set = 1;
996 }
997 }
998
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 &&
1004 !wep_keys_set) {
1005 use_crypt = 0;
1006 } else {
1007 /* Assume that dynamic WEP-104 keys will be used and
1008 * set cipher suites in order for drivers to expect
1009 * encryption. */
1010 cipher_pairwise = cipher_group = CIPHER_WEP104;
1011 }
1012 }
1013#endif /* IEEE8021X_EAPOL */
1014
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);
1018 }
1019
1020 wpa_drv_set_drop_unencrypted(wpa_s, use_crypt);
1021 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1022 os_memset(&params, 0, sizeof(params));
1023 if (bss) {
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;
1029 } else {
1030 params.ssid = ssid->ssid;
1031 params.ssid_len = ssid->ssid_len;
1032 }
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];
1046 }
1047 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1048
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;
1053 if (ssid->psk_set)
1054 params.psk = ssid->psk;
1055 }
1056
1057#ifdef CONFIG_IEEE80211W
1058 switch (ssid->ieee80211w) {
1059 case NO_IEEE80211W:
1060 params.mgmt_frame_protection = NO_MGMT_FRAME_PROTECTION;
1061 break;
1062 case IEEE80211W_OPTIONAL:
1063 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_OPTIONAL;
1064 break;
1065 case IEEE80211W_REQUIRED:
1066 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_REQUIRED;
1067 break;
1068 }
1069#endif /* CONFIG_IEEE80211W */
1070
1071 if (wpa_s->use_client_mlme)
1072 ret = ieee80211_sta_associate(wpa_s, &params);
1073 else
1074 ret = wpa_drv_associate(wpa_s, &params);
1075 if (ret < 0) {
1076 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1077 "failed");
1078 /* try to continue anyway; new association will be tried again
1079 * after timeout */
1080 assoc_failed = 1;
1081 }
1082
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
1088 * management. */
1089 wpa_supplicant_cancel_auth_timeout(wpa_s);
1090 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1091 } else {
1092 /* Timeout for IEEE 802.11 authentication and association */
1093 int timeout;
1094 if (assoc_failed)
1095 timeout = 5;
1096 else if (wpa_s->conf->ap_scan == 1)
1097 timeout = 10;
1098 else
1099 timeout = 60;
1100 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1101 }
1102
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);
1107 }
1108
1109 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1110 /*
1111 * Do not allow EAP session resumption between different
1112 * network configurations.
1113 */
1114 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1115 }
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);
1119}
1120
1121
1122/**
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
1126 *
1127 * This function is used to request %wpa_supplicant to disassociate with the
1128 * current AP.
1129 */
1130void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1131 int reason_code)
1132{
1133 u8 *addr = NULL;
1134 if (os_memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 0)
1135 {
1136 if (wpa_s->use_client_mlme)
1137 ieee80211_sta_disassociate(wpa_s, reason_code);
1138 else
1139 wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1140 addr = wpa_s->bssid;
1141 }
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);
1147}
1148
1149
1150/**
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
1154 *
1155 * This function is used to request %wpa_supplicant to disassociate with the
1156 * current AP.
1157 */
1158void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1159 int reason_code)
1160{
1161 u8 *addr = NULL;
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)
1164 {
1165 if (wpa_s->use_client_mlme)
1166 ieee80211_sta_deauthenticate(wpa_s, reason_code);
1167 else
1168 wpa_drv_deauthenticate(wpa_s, wpa_s->bssid,
1169 reason_code);
1170 addr = wpa_s->bssid;
1171 }
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);
1178}
1179
1180
1181static int wpa_supplicant_get_scan_results_old(struct wpa_supplicant *wpa_s)
1182{
1183#define SCAN_AP_LIMIT 128
1184 struct wpa_scan_result *results;
1185 int num, i;
1186 struct wpa_scan_results *res;
1187
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 "
1191 "results");
1192 return -1;
1193 }
1194
1195 num = wpa_drv_get_scan_results(wpa_s, results, SCAN_AP_LIMIT);
1196 wpa_printf(MSG_DEBUG, "Scan results: %d", num);
1197 if (num < 0) {
1198 wpa_printf(MSG_DEBUG, "Failed to get scan results");
1199 os_free(results);
1200 return -1;
1201 }
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;
1206 }
1207
1208 wpa_scan_results_free(wpa_s->scan_res);
1209 wpa_s->scan_res = NULL;
1210
1211 /* Convert old scan result data structure to the new one */
1212 res = os_zalloc(sizeof(*res));
1213 if (res == NULL) {
1214 os_free(results);
1215 return -1;
1216 }
1217 res->res = os_zalloc(num * sizeof(struct wpa_scan_res *));
1218 if (res->res == NULL) {
1219 os_free(results);
1220 os_free(res);
1221 return -1;
1222 }
1223
1224 for (i = 0; i < num; i++) {
1225 struct wpa_scan_result *bss = &results[i];
1226 struct wpa_scan_res *r;
1227 size_t ie_len;
1228 u8 *pos;
1229
1230 ie_len = 2 + bss->ssid_len + bss->rsn_ie_len + bss->wpa_ie_len;
1231 if (bss->maxrate)
1232 ie_len += 3;
1233 if (bss->mdie_present)
1234 ie_len += 5;
1235
1236 r = os_zalloc(sizeof(*r) + ie_len);
1237 if (r == NULL)
1238 break;
1239
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;
1246 r->tsf = bss->tsf;
1247 r->ie_len = ie_len;
1248
1249 pos = (u8 *) (r + 1);
1250
1251 /* SSID IE */
1252 *pos++ = WLAN_EID_SSID;
1253 *pos++ = bss->ssid_len;
1254 os_memcpy(pos, bss->ssid, bss->ssid_len);
1255 pos += bss->ssid_len;
1256
1257 if (bss->maxrate) {
1258 /* Fake Supported Rate IE to include max rate */
1259 *pos++ = WLAN_EID_SUPP_RATES;
1260 *pos++ = 1;
1261 *pos++ = bss->maxrate;
1262 }
1263
1264 if (bss->rsn_ie_len) {
1265 os_memcpy(pos, bss->rsn_ie, bss->rsn_ie_len);
1266 pos += bss->rsn_ie_len;
1267 }
1268
1269 if (bss->mdie_present) {
1270 os_memcpy(pos, bss->mdie, 5);
1271 pos += 5;
1272 }
1273
1274 if (bss->wpa_ie_len) {
1275 os_memcpy(pos, bss->wpa_ie, bss->wpa_ie_len);
1276 pos += bss->wpa_ie_len;
1277 }
1278
1279 res->res[res->num++] = r;
1280 }
1281
1282 os_free(results);
1283 wpa_s->scan_res = res;
1284
1285 return 0;
1286}
1287
1288
1289/**
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
1293 *
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.
1296 */
1297int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s)
1298{
1299 int ret;
1300
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");
1306 ret = -1;
1307 } else
1308 ret = 0;
1309 } else if (wpa_s->driver->get_scan_results2 == NULL)
1310 ret = wpa_supplicant_get_scan_results_old(wpa_s);
1311 else {
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");
1316 ret = -1;
1317 } else
1318 ret = 0;
1319 }
1320
1321 if (wpa_s->scan_res)
1322 wpa_scan_sort_results(wpa_s->scan_res);
1323
1324 return ret;
1325}
1326
1327
1328/**
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
1332 */
1333struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
1334{
1335 struct wpa_ssid *entry;
1336 u8 ssid[MAX_SSID_LEN];
1337 int res;
1338 size_t ssid_len;
1339 u8 bssid[ETH_ALEN];
1340 int wired;
1341
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 "
1345 "MLME.");
1346 return NULL;
1347 }
1348 } else {
1349 res = wpa_drv_get_ssid(wpa_s, ssid);
1350 if (res < 0) {
1351 wpa_printf(MSG_WARNING, "Could not read SSID from "
1352 "driver.");
1353 return NULL;
1354 }
1355 ssid_len = res;
1356 }
1357
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.");
1362 return NULL;
1363 }
1364
1365 wired = wpa_s->conf->ap_scan == 0 && wpa_s->driver &&
1366 os_strcmp(wpa_s->driver->name, "wired") == 0;
1367
1368 entry = wpa_s->conf->ssid;
1369 while (entry) {
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))
1375 return entry;
1376 entry = entry->next;
1377 }
1378
1379 return NULL;
1380}
1381
1382
1383static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
1384 const char *name)
1385{
1386 int i;
1387
1388 if (wpa_s == NULL)
1389 return -1;
1390
1391 if (wpa_supplicant_drivers[0] == NULL) {
1392 wpa_printf(MSG_ERROR, "No driver interfaces build into "
1393 "wpa_supplicant.");
1394 return -1;
1395 }
1396
1397 if (name == NULL) {
1398 /* default to first driver in the list */
1399 wpa_s->driver = wpa_supplicant_drivers[0];
1400 return 0;
1401 }
1402
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];
1406 return 0;
1407 }
1408 }
1409
1410 wpa_printf(MSG_ERROR, "Unsupported driver '%s'.\n", name);
1411 return -1;
1412}
1413
1414
1415void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1416 const u8 *buf, size_t len)
1417{
1418 struct wpa_supplicant *wpa_s = ctx;
1419
1420 wpa_printf(MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
1421 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
1422
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");
1426 return;
1427 }
1428
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(
1436 wpa_s,
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) ?
1440 70 : 10, 0);
1441 }
1442 wpa_s->eapol_received++;
1443
1444 if (wpa_s->countermeasures) {
1445 wpa_printf(MSG_INFO, "WPA: Countermeasures - dropped EAPOL "
1446 "packet");
1447 return;
1448 }
1449
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. */
1455
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)
1460 return;
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) {
1466 /*
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.
1471 */
1472 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1473 }
1474}
1475
1476
1477void wpa_supplicant_sta_free_hw_features(struct wpa_hw_modes *hw_features,
1478 size_t num_hw_features)
1479{
1480 ieee80211_sta_free_hw_features(hw_features, num_hw_features);
1481}
1482
1483
1484void wpa_supplicant_sta_rx(void *ctx, const u8 *buf, size_t len,
1485 struct ieee80211_rx_status *rx_status)
1486{
1487 struct wpa_supplicant *wpa_s = ctx;
1488 ieee80211_sta_rx(wpa_s, buf, len, rx_status);
1489}
1490
1491
1492/**
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
1496 *
1497 * This function is called to initialize driver interface parameters.
1498 * wpa_drv_init() must have been called before this function to initialize the
1499 * driver interface.
1500 */
1501int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
1502{
1503 static int interface_count = 0;
1504
1505 if (wpa_s->driver->send_eapol) {
1506 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
1507 if (addr)
1508 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
1509 } else {
1510 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
1511 wpa_drv_get_mac_addr(wpa_s),
1512 ETH_P_EAPOL,
1513 wpa_supplicant_rx_eapol, wpa_s, 0);
1514 if (wpa_s->l2 == NULL)
1515 return -1;
1516 }
1517
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");
1520 return -1;
1521 }
1522
1523 wpa_printf(MSG_DEBUG, "Own MAC address: " MACSTR,
1524 MAC2STR(wpa_s->own_addr));
1525
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,
1530 wpa_s->own_addr,
1531 ETH_P_EAPOL,
1532 wpa_supplicant_rx_eapol, wpa_s,
1533 0);
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);
1538 return -1;
1539 }
1540 }
1541
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. */
1552 } else {
1553 wpa_printf(MSG_ERROR, "Failed to enable WPA in the "
1554 "driver.");
1555 return -1;
1556 }
1557 }
1558
1559 wpa_clear_keys(wpa_s, NULL);
1560
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);
1564
1565 wpa_drv_set_drop_unencrypted(wpa_s, 1);
1566
1567 wpa_printf(MSG_DEBUG, "RSN: flushing PMKID list in the driver");
1568 wpa_drv_flush_pmkid(wpa_s);
1569
1570 wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN;
1571 wpa_supplicant_req_scan(wpa_s, interface_count, 100000);
1572 interface_count++;
1573
1574 return 0;
1575}
1576
1577
1578static int wpa_supplicant_daemon(const char *pid_file)
1579{
1580 wpa_printf(MSG_DEBUG, "Daemonize..");
1581 return os_daemonize(pid_file);
1582}
1583
1584
1585static struct wpa_supplicant * wpa_supplicant_alloc(void)
1586{
1587 struct wpa_supplicant *wpa_s;
1588
1589 wpa_s = os_zalloc(sizeof(*wpa_s));
1590 if (wpa_s == NULL)
1591 return NULL;
1592 wpa_s->scan_req = 1;
1593
1594 return wpa_s;
1595}
1596
1597
1598static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
1599 struct wpa_interface *iface)
1600{
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");
1607
1608 if (wpa_supplicant_set_driver(wpa_s, iface->driver) < 0) {
1609 return -1;
1610 }
1611
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'.",
1618 iface->confname);
1619 return -1;
1620 }
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);
1630 return -1;
1631 }
1632
1633 /*
1634 * Override ctrl_interface and driver_param if set on command
1635 * line.
1636 */
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);
1641 }
1642
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);
1647 }
1648 } else
1649 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
1650 iface->driver_param);
1651
1652 if (wpa_s->conf == NULL) {
1653 wpa_printf(MSG_ERROR, "\nNo configuration found.");
1654 return -1;
1655 }
1656
1657 if (iface->ifname == NULL) {
1658 wpa_printf(MSG_ERROR, "\nInterface name is required.");
1659 return -1;
1660 }
1661 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
1662 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
1663 iface->ifname);
1664 return -1;
1665 }
1666 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
1667
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);
1673 return -1;
1674 }
1675 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
1676 sizeof(wpa_s->bridge_ifname));
1677 }
1678
1679 return 0;
1680}
1681
1682
1683static int wpa_supplicant_init_iface2(struct wpa_supplicant *wpa_s)
1684{
1685 const char *ifname;
1686 struct wpa_driver_capa capa;
1687
1688 wpa_printf(MSG_DEBUG, "Initializing interface (2) '%s'",
1689 wpa_s->ifname);
1690
1691 /* RSNA Supplicant Key Management - INITIALIZE */
1692 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1693 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1694
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()
1698 * call. */
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");
1702 return -1;
1703 }
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);
1707 return -1;
1708 }
1709
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));
1715 }
1716
1717 if (wpa_supplicant_init_wpa(wpa_s) < 0)
1718 return -1;
1719
1720 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
1721 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
1722 NULL);
1723 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1724
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");
1730 return -1;
1731 }
1732
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");
1738 return -1;
1739 }
1740
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");
1746 return -1;
1747 }
1748
1749 if (wpa_supplicant_driver_init(wpa_s) < 0)
1750 return -1;
1751
1752 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
1753
1754 if (wpa_supplicant_init_eapol(wpa_s) < 0)
1755 return -1;
1756 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
1757
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);
1769 return -1;
1770 }
1771
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))
1776 return -1;
1777 }
1778 if (capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE)
1779 wpa_s->driver_4way_handshake = 1;
1780 }
1781
1782 return 0;
1783}
1784
1785
1786static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s)
1787{
1788 if (wpa_s->drv_priv) {
1789 wpa_supplicant_deauthenticate(wpa_s,
1790 WLAN_REASON_DEAUTH_LEAVING);
1791
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 "
1797 "driver.");
1798 }
1799
1800 wpa_drv_set_drop_unencrypted(wpa_s, 0);
1801 wpa_drv_set_countermeasures(wpa_s, 0);
1802 wpa_clear_keys(wpa_s, NULL);
1803 }
1804
1805 wpas_dbus_unregister_iface(wpa_s);
1806
1807 wpa_supplicant_cleanup(wpa_s);
1808
1809 if (wpa_s->drv_priv)
1810 wpa_drv_deinit(wpa_s);
1811}
1812
1813
1814/**
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
1819 *
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.
1825 */
1826struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
1827 struct wpa_interface *iface)
1828{
1829 struct wpa_supplicant *wpa_s;
1830
1831 if (global == NULL || iface == NULL)
1832 return NULL;
1833
1834 wpa_s = wpa_supplicant_alloc();
1835 if (wpa_s == NULL)
1836 return NULL;
1837
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",
1841 iface->ifname);
1842 wpa_supplicant_deinit_iface(wpa_s);
1843 os_free(wpa_s);
1844 return NULL;
1845 }
1846
1847 wpa_s->global = global;
1848
1849 /* Register the interface with the dbus control interface */
1850 if (wpas_dbus_register_iface(wpa_s)) {
1851 wpa_supplicant_deinit_iface(wpa_s);
1852 os_free(wpa_s);
1853 return NULL;
1854 }
1855
1856 wpa_s->next = global->ifaces;
1857 global->ifaces = wpa_s;
1858
1859 wpa_printf(MSG_DEBUG, "Added interface %s", wpa_s->ifname);
1860
1861 return wpa_s;
1862}
1863
1864
1865/**
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
1870 *
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.
1875 */
1876int wpa_supplicant_remove_iface(struct wpa_global *global,
1877 struct wpa_supplicant *wpa_s)
1878{
1879 struct wpa_supplicant *prev;
1880
1881 /* Remove interface from the global list of interfaces */
1882 prev = global->ifaces;
1883 if (prev == wpa_s) {
1884 global->ifaces = wpa_s->next;
1885 } else {
1886 while (prev && prev->next != wpa_s)
1887 prev = prev->next;
1888 if (prev == NULL)
1889 return -1;
1890 prev->next = wpa_s->next;
1891 }
1892
1893 wpa_printf(MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
1894
1895 wpa_supplicant_deinit_iface(wpa_s);
1896 os_free(wpa_s);
1897
1898 return 0;
1899}
1900
1901
1902/**
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
1907 */
1908struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
1909 const char *ifname)
1910{
1911 struct wpa_supplicant *wpa_s;
1912
1913 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1914 if (os_strcmp(wpa_s->ifname, ifname) == 0)
1915 return wpa_s;
1916 }
1917 return NULL;
1918}
1919
1920
1921/**
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
1925 *
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.
1929 */
1930struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
1931{
1932 struct wpa_global *global;
1933 int ret;
1934
1935 if (params == NULL)
1936 return NULL;
1937
1938 wpa_debug_open_file(params->wpa_debug_file_path);
1939
1940 ret = eap_peer_register_methods();
1941 if (ret) {
1942 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
1943 if (ret == -2)
1944 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
1945 "the same EAP type.");
1946 return NULL;
1947 }
1948
1949 global = os_zalloc(sizeof(*global));
1950 if (global == NULL)
1951 return NULL;
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;
1966
1967 if (eloop_init(global)) {
1968 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1969 wpa_supplicant_deinit(global);
1970 return NULL;
1971 }
1972
1973 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
1974 if (global->ctrl_iface == NULL) {
1975 wpa_supplicant_deinit(global);
1976 return NULL;
1977 }
1978
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);
1984 return NULL;
1985 }
1986 }
1987
1988 return global;
1989}
1990
1991
1992/**
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
1996 *
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.
2000 */
2001int wpa_supplicant_run(struct wpa_global *global)
2002{
2003 struct wpa_supplicant *wpa_s;
2004
2005 if (global->params.daemonize &&
2006 wpa_supplicant_daemon(global->params.pid_file))
2007 return -1;
2008
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(
2013 wpa_s->ctrl_iface);
2014 }
2015
2016 eloop_register_signal_terminate(wpa_supplicant_terminate, NULL);
2017 eloop_register_signal_reconfig(wpa_supplicant_reconfig, NULL);
2018
2019 eloop_run();
2020
2021 return 0;
2022}
2023
2024
2025/**
2026 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
2027 * @global: Pointer to global data from wpa_supplicant_init()
2028 *
2029 * This function is called to deinitialize %wpa_supplicant and to free all
2030 * allocated resources. Remaining network interfaces will also be removed.
2031 */
2032void wpa_supplicant_deinit(struct wpa_global *global)
2033{
2034 if (global == NULL)
2035 return;
2036
2037 while (global->ifaces)
2038 wpa_supplicant_remove_iface(global, global->ifaces);
2039
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);
2044
2045 eap_peer_unregister_methods();
2046
2047 eloop_destroy();
2048
2049 if (global->params.pid_file) {
2050 os_daemonize_terminate(global->params.pid_file);
2051 os_free(global->params.pid_file);
2052 }
2053 os_free(global->params.ctrl_interface);
2054
2055 os_free(global);
2056 wpa_debug_close_file();
2057}
Unnamed repository; edit this file 'description' to name the repository.