]> 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
Added support for IBSS scanning into driver_test
[thirdparty/hostap.git] / wpa_supplicant / wpa_supplicant.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant
6f78f2fb 3 * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
6fc6879b
JM		 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"
116654ce 41#include "wps_supplicant.h"
11ef8d35 42#include "ibss_rsn.h"
6fc6879b
JM		 43
44const char *wpa_supplicant_version =
45"wpa_supplicant v" VERSION_STR "\n"
6f78f2fb 46"Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi> and contributors";
6fc6879b
JM		 47
48const char *wpa_supplicant_license =
49"This program is free software. You can distribute it and/or modify it\n"
50"under the terms of the GNU General Public License version 2.\n"
51"\n"
52"Alternatively, this software may be distributed under the terms of the\n"
53"BSD license. See README and COPYING for more details.\n"
54#ifdef EAP_TLS_OPENSSL
55"\nThis product includes software developed by the OpenSSL Project\n"
56"for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
57#endif /* EAP_TLS_OPENSSL */
58;
59
60#ifndef CONFIG_NO_STDOUT_DEBUG
61/* Long text divided into parts in order to fit in C89 strings size limits. */
62const char *wpa_supplicant_full_license1 =
63"This program is free software; you can redistribute it and/or modify\n"
64"it under the terms of the GNU General Public License version 2 as\n"
65"published by the Free Software Foundation.\n"
66"\n"
67"This program is distributed in the hope that it will be useful,\n"
68"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
69"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
70"GNU General Public License for more details.\n"
71"\n";
72const char *wpa_supplicant_full_license2 =
73"You should have received a copy of the GNU General Public License\n"
74"along with this program; if not, write to the Free Software\n"
75"Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
76"\n"
77"Alternatively, this software may be distributed under the terms of the\n"
78"BSD license.\n"
79"\n"
80"Redistribution and use in source and binary forms, with or without\n"
81"modification, are permitted provided that the following conditions are\n"
82"met:\n"
83"\n";
84const char *wpa_supplicant_full_license3 =
85"1. Redistributions of source code must retain the above copyright\n"
86" notice, this list of conditions and the following disclaimer.\n"
87"\n"
88"2. Redistributions in binary form must reproduce the above copyright\n"
89" notice, this list of conditions and the following disclaimer in the\n"
90" documentation and/or other materials provided with the distribution.\n"
91"\n";
92const char *wpa_supplicant_full_license4 =
93"3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
94" names of its contributors may be used to endorse or promote products\n"
95" derived from this software without specific prior written permission.\n"
96"\n"
97"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
98"\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
99"LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
100"A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
101const char *wpa_supplicant_full_license5 =
102"OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
103"SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
104"LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
105"DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
106"THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
107"(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
108"OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
109"\n";
110#endif /* CONFIG_NO_STDOUT_DEBUG */
111
6fc6879b
JM		 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;
a8e16edc 190 if (is_zero_ether_addr(bssid))
6fc6879b
JM		 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 &&
e519314e 215 wpa_s->driver && IS_WIRED(wpa_s->driver))
6fc6879b
JM		 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
53895c3b
JM		 254#ifdef CONFIG_IBSS_RSN
255 if (ssid->mode == IEEE80211_MODE_IBSS &&
256 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
257 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
258 /*
259 * RSN IBSS authentication is per-STA and we can disable the
260 * per-BSSID EAPOL authentication.
261 */
262 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
263 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
264 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
265 return;
266 }
267#endif /* CONFIG_IBSS_RSN */
268
0a40ec6a
JM		 269 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
270 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
271
6fc6879b
JM		 272 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
273 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
274 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
275 else
276 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
277
278 os_memset(&eapol_conf, 0, sizeof(eapol_conf));
279 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
280 eapol_conf.accept_802_1x_keys = 1;
281 eapol_conf.required_keys = 0;
282 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
283 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
284 }
285 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
286 eapol_conf.required_keys |=
287 EAPOL_REQUIRE_KEY_BROADCAST;
288 }
289
e519314e 290 if (wpa_s->conf && wpa_s->driver && IS_WIRED(wpa_s->driver)) {
6fc6879b
JM		 291 eapol_conf.required_keys = 0;
292 }
293 }
294 if (wpa_s->conf)
295 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
296 eapol_conf.workaround = ssid->eap_workaround;
56586197
JM		 297 eapol_conf.eap_disabled =
298 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
ad08c363
JM		 299 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
300 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
6fc6879b
JM		 301 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
302#endif /* IEEE8021X_EAPOL */
303}
304
305
306/**
307 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
308 * @wpa_s: Pointer to wpa_supplicant data
309 * @ssid: Configuration data for the network
310 *
311 * This function is used to configure WPA state machine and related parameters
312 * to a mode where WPA is not enabled. This is called as part of the
313 * authentication configuration when the selected network does not use WPA.
314 */
315void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
316 struct wpa_ssid *ssid)
317{
318 int i;
319
ad08c363
JM		 320 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
321 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
322 else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
6fc6879b
JM		 323 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
324 else
325 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
326 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
327 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
328 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
329 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
330 wpa_s->group_cipher = WPA_CIPHER_NONE;
331 wpa_s->mgmt_group_cipher = 0;
332
333 for (i = 0; i < NUM_WEP_KEYS; i++) {
334 if (ssid->wep_key_len[i] > 5) {
335 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
336 wpa_s->group_cipher = WPA_CIPHER_WEP104;
337 break;
338 } else if (ssid->wep_key_len[i] > 0) {
339 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
340 wpa_s->group_cipher = WPA_CIPHER_WEP40;
341 break;
342 }
343 }
344
345 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
346 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
347 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
348 wpa_s->pairwise_cipher);
349 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
350#ifdef CONFIG_IEEE80211W
351 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
352 wpa_s->mgmt_group_cipher);
353#endif /* CONFIG_IEEE80211W */
354
355 pmksa_cache_clear_current(wpa_s->wpa);
356}
357
358
359static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
360{
361 scard_deinit(wpa_s->scard);
362 wpa_s->scard = NULL;
363 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
364 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
365 l2_packet_deinit(wpa_s->l2);
366 wpa_s->l2 = NULL;
367 if (wpa_s->l2_br) {
368 l2_packet_deinit(wpa_s->l2_br);
369 wpa_s->l2_br = NULL;
370 }
371
372 if (wpa_s->ctrl_iface) {
373 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
374 wpa_s->ctrl_iface = NULL;
375 }
376 if (wpa_s->conf != NULL) {
377 wpa_config_free(wpa_s->conf);
378 wpa_s->conf = NULL;
379 }
380
381 os_free(wpa_s->confname);
382 wpa_s->confname = NULL;
383
384 wpa_sm_set_eapol(wpa_s->wpa, NULL);
385 eapol_sm_deinit(wpa_s->eapol);
386 wpa_s->eapol = NULL;
387
388 rsn_preauth_deinit(wpa_s->wpa);
389
390 pmksa_candidate_free(wpa_s->wpa);
391 wpa_sm_deinit(wpa_s->wpa);
392 wpa_s->wpa = NULL;
393 wpa_blacklist_clear(wpa_s);
394
395 wpa_scan_results_free(wpa_s->scan_res);
396 wpa_s->scan_res = NULL;
397
398 wpa_supplicant_cancel_scan(wpa_s);
399 wpa_supplicant_cancel_auth_timeout(wpa_s);
400
401 ieee80211_sta_deinit(wpa_s);
116654ce
JM		 402
403 wpas_wps_deinit(wpa_s);
11ef8d35
JM		 404
405#ifdef CONFIG_IBSS_RSN
406 ibss_rsn_deinit(wpa_s->ibss_rsn);
407 wpa_s->ibss_rsn = NULL;
408#endif /* CONFIG_IBSS_RSN */
6fc6879b
JM		 409}
410
411
412/**
413 * wpa_clear_keys - Clear keys configured for the driver
414 * @wpa_s: Pointer to wpa_supplicant data
415 * @addr: Previously used BSSID or %NULL if not available
416 *
417 * This function clears the encryption keys that has been previously configured
418 * for the driver.
419 */
420void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
421{
422 u8 *bcast = (u8 *) "\xff\xff\xff\xff\xff\xff";
423
424 if (wpa_s->keys_cleared) {
425 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
426 * timing issues with keys being cleared just before new keys
427 * are set or just after association or something similar. This
428 * shows up in group key handshake failing often because of the
429 * client not receiving the first encrypted packets correctly.
430 * Skipping some of the extra key clearing steps seems to help
431 * in completing group key handshake more reliably. */
432 wpa_printf(MSG_DEBUG, "No keys have been configured - "
433 "skip key clearing");
434 return;
435 }
436
437 /* MLME-DELETEKEYS.request */
438 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 0, 0, NULL, 0, NULL, 0);
439 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 1, 0, NULL, 0, NULL, 0);
440 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 2, 0, NULL, 0, NULL, 0);
441 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 3, 0, NULL, 0, NULL, 0);
442 if (addr) {
443 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
444 0);
445 /* MLME-SETPROTECTION.request(None) */
446 wpa_drv_mlme_setprotection(
447 wpa_s, addr,
448 MLME_SETPROTECTION_PROTECT_TYPE_NONE,
449 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
450 }
451 wpa_s->keys_cleared = 1;
452}
453
454
455/**
456 * wpa_supplicant_state_txt - Get the connection state name as a text string
457 * @state: State (wpa_state; WPA_*)
458 * Returns: The state name as a printable text string
459 */
460const char * wpa_supplicant_state_txt(int state)
461{
462 switch (state) {
463 case WPA_DISCONNECTED:
464 return "DISCONNECTED";
465 case WPA_INACTIVE:
466 return "INACTIVE";
467 case WPA_SCANNING:
468 return "SCANNING";
469 case WPA_ASSOCIATING:
470 return "ASSOCIATING";
471 case WPA_ASSOCIATED:
472 return "ASSOCIATED";
473 case WPA_4WAY_HANDSHAKE:
474 return "4WAY_HANDSHAKE";
475 case WPA_GROUP_HANDSHAKE:
476 return "GROUP_HANDSHAKE";
477 case WPA_COMPLETED:
478 return "COMPLETED";
479 default:
480 return "UNKNOWN";
481 }
482}
483
484
485/**
486 * wpa_supplicant_set_state - Set current connection state
487 * @wpa_s: Pointer to wpa_supplicant data
488 * @state: The new connection state
489 *
490 * This function is called whenever the connection state changes, e.g.,
491 * association is completed for WPA/WPA2 4-Way Handshake is started.
492 */
493void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, wpa_states state)
494{
495 wpa_printf(MSG_DEBUG, "State: %s -> %s",
496 wpa_supplicant_state_txt(wpa_s->wpa_state),
497 wpa_supplicant_state_txt(state));
498
499 wpa_supplicant_dbus_notify_state_change(wpa_s, state,
500 wpa_s->wpa_state);
501
502 if (state == WPA_COMPLETED && wpa_s->new_connection) {
503#if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
504 struct wpa_ssid *ssid = wpa_s->current_ssid;
505 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
506 MACSTR " completed %s [id=%d id_str=%s]",
507 MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ?
508 "(reauth)" : "(auth)",
509 ssid ? ssid->id : -1,
510 ssid && ssid->id_str ? ssid->id_str : "");
511#endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
512 wpa_s->new_connection = 0;
513 wpa_s->reassociated_connection = 1;
514 wpa_drv_set_operstate(wpa_s, 1);
515 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
516 state == WPA_ASSOCIATED) {
517 wpa_s->new_connection = 1;
518 wpa_drv_set_operstate(wpa_s, 0);
519 }
520 wpa_s->wpa_state = state;
521}
522
523
524static void wpa_supplicant_terminate(int sig, void *eloop_ctx,
525 void *signal_ctx)
526{
527 struct wpa_global *global = eloop_ctx;
528 struct wpa_supplicant *wpa_s;
529 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
530 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d "
531 "received", sig);
532 }
533 eloop_terminate();
534}
535
536
537static void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
538{
539 wpa_s->pairwise_cipher = 0;
540 wpa_s->group_cipher = 0;
541 wpa_s->mgmt_group_cipher = 0;
542 wpa_s->key_mgmt = 0;
543 wpa_s->wpa_state = WPA_DISCONNECTED;
544}
545
546
547/**
548 * wpa_supplicant_reload_configuration - Reload configuration data
549 * @wpa_s: Pointer to wpa_supplicant data
550 * Returns: 0 on success or -1 if configuration parsing failed
551 *
552 * This function can be used to request that the configuration data is reloaded
553 * (e.g., after configuration file change). This function is reloading
554 * configuration only for one interface, so this may need to be called multiple
555 * times if %wpa_supplicant is controlling multiple interfaces and all
556 * interfaces need reconfiguration.
557 */
558int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
559{
560 struct wpa_config *conf;
561 int reconf_ctrl;
562 if (wpa_s->confname == NULL)
563 return -1;
564 conf = wpa_config_read(wpa_s->confname);
565 if (conf == NULL) {
566 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
567 "file '%s' - exiting", wpa_s->confname);
568 return -1;
569 }
570
571 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
572 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
573 os_strcmp(conf->ctrl_interface,
574 wpa_s->conf->ctrl_interface) != 0);
575
576 if (reconf_ctrl && wpa_s->ctrl_iface) {
577 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
578 wpa_s->ctrl_iface = NULL;
579 }
580
581 eapol_sm_invalidate_cached_session(wpa_s->eapol);
582 wpa_s->current_ssid = NULL;
583 /*
584 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
585 * pkcs11_engine_path, pkcs11_module_path.
586 */
56586197 587 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
6fc6879b
JM		 588 /*
589 * Clear forced success to clear EAP state for next
590 * authentication.
591 */
592 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
593 }
594 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
595 wpa_sm_set_config(wpa_s->wpa, NULL);
596 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
597 rsn_preauth_deinit(wpa_s->wpa);
598 wpa_config_free(wpa_s->conf);
599 wpa_s->conf = conf;
600 if (reconf_ctrl)
601 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
602
603 wpa_supplicant_clear_status(wpa_s);
604 wpa_s->reassociate = 1;
605 wpa_supplicant_req_scan(wpa_s, 0, 0);
606 wpa_msg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
607 return 0;
608}
609
610
611static void wpa_supplicant_reconfig(int sig, void *eloop_ctx,
612 void *signal_ctx)
613{
614 struct wpa_global *global = eloop_ctx;
615 struct wpa_supplicant *wpa_s;
616 wpa_printf(MSG_DEBUG, "Signal %d received - reconfiguring", sig);
617 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
618 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
619 eloop_terminate();
620 }
621 }
622}
623
624
625static wpa_cipher cipher_suite2driver(int cipher)
626{
627 switch (cipher) {
628 case WPA_CIPHER_NONE:
629 return CIPHER_NONE;
630 case WPA_CIPHER_WEP40:
631 return CIPHER_WEP40;
632 case WPA_CIPHER_WEP104:
633 return CIPHER_WEP104;
634 case WPA_CIPHER_CCMP:
635 return CIPHER_CCMP;
636 case WPA_CIPHER_TKIP:
637 default:
638 return CIPHER_TKIP;
639 }
640}
641
642
643static wpa_key_mgmt key_mgmt2driver(int key_mgmt)
644{
645 switch (key_mgmt) {
646 case WPA_KEY_MGMT_NONE:
647 return KEY_MGMT_NONE;
648 case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
649 return KEY_MGMT_802_1X_NO_WPA;
650 case WPA_KEY_MGMT_IEEE8021X:
651 return KEY_MGMT_802_1X;
652 case WPA_KEY_MGMT_WPA_NONE:
653 return KEY_MGMT_WPA_NONE;
654 case WPA_KEY_MGMT_FT_IEEE8021X:
655 return KEY_MGMT_FT_802_1X;
656 case WPA_KEY_MGMT_FT_PSK:
657 return KEY_MGMT_FT_PSK;
56586197
JM		 658 case WPA_KEY_MGMT_IEEE8021X_SHA256:
659 return KEY_MGMT_802_1X_SHA256;
660 case WPA_KEY_MGMT_PSK_SHA256:
661 return KEY_MGMT_PSK_SHA256;
ad08c363
JM		 662 case WPA_KEY_MGMT_WPS:
663 return KEY_MGMT_WPS;
6fc6879b
JM		 664 case WPA_KEY_MGMT_PSK:
665 default:
666 return KEY_MGMT_PSK;
667 }
668}
669
670
671static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
672 struct wpa_ssid *ssid,
673 struct wpa_ie_data *ie)
674{
675 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
676 if (ret) {
677 if (ret == -2) {
678 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
679 "from association info");
680 }
681 return -1;
682 }
683
684 wpa_printf(MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set cipher "
685 "suites");
686 if (!(ie->group_cipher & ssid->group_cipher)) {
687 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
688 "cipher 0x%x (mask 0x%x) - reject",
689 ie->group_cipher, ssid->group_cipher);
690 return -1;
691 }
692 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
693 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
694 "cipher 0x%x (mask 0x%x) - reject",
695 ie->pairwise_cipher, ssid->pairwise_cipher);
696 return -1;
697 }
698 if (!(ie->key_mgmt & ssid->key_mgmt)) {
699 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
700 "management 0x%x (mask 0x%x) - reject",
701 ie->key_mgmt, ssid->key_mgmt);
702 return -1;
703 }
704
705#ifdef CONFIG_IEEE80211W
0b60b0aa 706 if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
6fc6879b
JM		 707 ssid->ieee80211w == IEEE80211W_REQUIRED) {
708 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
709 "that does not support management frame protection - "
710 "reject");
711 return -1;
712 }
713#endif /* CONFIG_IEEE80211W */
714
715 return 0;
716}
717
718
719/**
720 * wpa_supplicant_set_suites - Set authentication and encryption parameters
721 * @wpa_s: Pointer to wpa_supplicant data
722 * @bss: Scan results for the selected BSS, or %NULL if not available
723 * @ssid: Configuration data for the selected network
724 * @wpa_ie: Buffer for the WPA/RSN IE
725 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
726 * used buffer length in case the functions returns success.
727 * Returns: 0 on success or -1 on failure
728 *
729 * This function is used to configure authentication and encryption parameters
730 * based on the network configuration and scan result for the selected BSS (if
731 * available).
732 */
733int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
734 struct wpa_scan_res *bss,
735 struct wpa_ssid *ssid,
736 u8 *wpa_ie, size_t *wpa_ie_len)
737{
738 struct wpa_ie_data ie;
739 int sel, proto;
740 const u8 *bss_wpa, *bss_rsn;
741
742 if (bss) {
743 bss_wpa = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
744 bss_rsn = wpa_scan_get_ie(bss, WLAN_EID_RSN);
745 } else
746 bss_wpa = bss_rsn = NULL;
747
748 if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
749 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
750 (ie.group_cipher & ssid->group_cipher) &&
751 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
752 (ie.key_mgmt & ssid->key_mgmt)) {
753 wpa_msg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
754 proto = WPA_PROTO_RSN;
755 } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
756 wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
757 (ie.group_cipher & ssid->group_cipher) &&
758 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
759 (ie.key_mgmt & ssid->key_mgmt)) {
760 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
761 proto = WPA_PROTO_WPA;
762 } else if (bss) {
763 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
764 return -1;
765 } else {
766 if (ssid->proto & WPA_PROTO_RSN)
767 proto = WPA_PROTO_RSN;
768 else
769 proto = WPA_PROTO_WPA;
770 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
771 os_memset(&ie, 0, sizeof(ie));
772 ie.group_cipher = ssid->group_cipher;
773 ie.pairwise_cipher = ssid->pairwise_cipher;
774 ie.key_mgmt = ssid->key_mgmt;
775#ifdef CONFIG_IEEE80211W
776 ie.mgmt_group_cipher =
777 ssid->ieee80211w != NO_IEEE80211W ?
778 WPA_CIPHER_AES_128_CMAC : 0;
779#endif /* CONFIG_IEEE80211W */
780 wpa_printf(MSG_DEBUG, "WPA: Set cipher suites based "
781 "on configuration");
782 } else
783 proto = ie.proto;
784 }
785
786 wpa_printf(MSG_DEBUG, "WPA: Selected cipher suites: group %d "
787 "pairwise %d key_mgmt %d proto %d",
788 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
789#ifdef CONFIG_IEEE80211W
790 if (ssid->ieee80211w) {
791 wpa_printf(MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
792 ie.mgmt_group_cipher);
793 }
794#endif /* CONFIG_IEEE80211W */
795
796 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
797 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
798 !!(ssid->proto & WPA_PROTO_RSN));
799
800 if (bss || !wpa_s->ap_ies_from_associnfo) {
801 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
802 bss_wpa ? 2 + bss_wpa[1] : 0) ||
803 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
804 bss_rsn ? 2 + bss_rsn[1] : 0))
805 return -1;
806 }
807
808 sel = ie.group_cipher & ssid->group_cipher;
809 if (sel & WPA_CIPHER_CCMP) {
810 wpa_s->group_cipher = WPA_CIPHER_CCMP;
811 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP");
812 } else if (sel & WPA_CIPHER_TKIP) {
813 wpa_s->group_cipher = WPA_CIPHER_TKIP;
814 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP");
815 } else if (sel & WPA_CIPHER_WEP104) {
816 wpa_s->group_cipher = WPA_CIPHER_WEP104;
817 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104");
818 } else if (sel & WPA_CIPHER_WEP40) {
819 wpa_s->group_cipher = WPA_CIPHER_WEP40;
820 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40");
821 } else {
822 wpa_printf(MSG_WARNING, "WPA: Failed to select group cipher.");
823 return -1;
824 }
825
826 sel = ie.pairwise_cipher & ssid->pairwise_cipher;
827 if (sel & WPA_CIPHER_CCMP) {
828 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
829 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP");
830 } else if (sel & WPA_CIPHER_TKIP) {
831 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
832 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP");
833 } else if (sel & WPA_CIPHER_NONE) {
834 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
835 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE");
836 } else {
837 wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
838 "cipher.");
839 return -1;
840 }
841
842 sel = ie.key_mgmt & ssid->key_mgmt;
843 if (0) {
844#ifdef CONFIG_IEEE80211R
845 } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
846 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
847 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
848 } else if (sel & WPA_KEY_MGMT_FT_PSK) {
849 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
850 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
851#endif /* CONFIG_IEEE80211R */
56586197
JM		 852#ifdef CONFIG_IEEE80211W
853 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
854 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
855 wpa_msg(wpa_s, MSG_DEBUG,
856 "WPA: using KEY_MGMT 802.1X with SHA256");
857 } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
858 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
859 wpa_msg(wpa_s, MSG_DEBUG,
860 "WPA: using KEY_MGMT PSK with SHA256");
861#endif /* CONFIG_IEEE80211W */
6fc6879b
JM		 862 } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
863 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
864 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
865 } else if (sel & WPA_KEY_MGMT_PSK) {
866 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
867 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
868 } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
869 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
870 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
871 } else {
872 wpa_printf(MSG_WARNING, "WPA: Failed to select authenticated "
873 "key management type.");
874 return -1;
875 }
876
877 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
878 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
879 wpa_s->pairwise_cipher);
880 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
881
882#ifdef CONFIG_IEEE80211W
883 sel = ie.mgmt_group_cipher;
884 if (ssid->ieee80211w == NO_IEEE80211W ||
0b60b0aa 885 !(ie.capabilities & WPA_CAPABILITY_MFPC))
6fc6879b
JM		 886 sel = 0;
887 if (sel & WPA_CIPHER_AES_128_CMAC) {
888 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
889 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
890 "AES-128-CMAC");
891 } else {
892 wpa_s->mgmt_group_cipher = 0;
893 wpa_msg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
894 }
895 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
896 wpa_s->mgmt_group_cipher);
897#endif /* CONFIG_IEEE80211W */
898
899 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
900 wpa_printf(MSG_WARNING, "WPA: Failed to generate WPA IE.");
901 return -1;
902 }
903
56586197
JM		 904 if (ssid->key_mgmt &
905 (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_FT_PSK | WPA_KEY_MGMT_PSK_SHA256))
6fc6879b
JM		 906 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
907 else
908 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
909
910 return 0;
911}
912
913
914/**
915 * wpa_supplicant_associate - Request association
916 * @wpa_s: Pointer to wpa_supplicant data
917 * @bss: Scan results for the selected BSS, or %NULL if not available
918 * @ssid: Configuration data for the selected network
919 *
920 * This function is used to request %wpa_supplicant to associate with a BSS.
921 */
922void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
923 struct wpa_scan_res *bss, struct wpa_ssid *ssid)
924{
925 u8 wpa_ie[80];
926 size_t wpa_ie_len;
927 int use_crypt, ret, i;
928 int algs = AUTH_ALG_OPEN_SYSTEM;
929 wpa_cipher cipher_pairwise, cipher_group;
930 struct wpa_driver_associate_params params;
931 int wep_keys_set = 0;
932 struct wpa_driver_capa capa;
933 int assoc_failed = 0;
934
935 wpa_s->reassociate = 0;
936 if (bss) {
937#ifdef CONFIG_IEEE80211R
938 const u8 *md = NULL;
939#endif /* CONFIG_IEEE80211R */
940 const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
941 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
942 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
943 ie ? wpa_ssid_txt(ie + 2, ie[1]) : "", bss->freq);
944 os_memset(wpa_s->bssid, 0, ETH_ALEN);
945 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
946#ifdef CONFIG_IEEE80211R
947 ie = wpa_scan_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
948 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
949 md = ie + 2;
950 wpa_sm_set_ft_params(wpa_s->wpa, md, NULL, 0, NULL);
91a05482
JM		 951 if (md) {
952 /* Prepare for the next transition */
953 wpa_ft_prepare_auth_request(wpa_s->wpa);
954 }
6fc6879b 955#endif /* CONFIG_IEEE80211R */
24c23d1b
JM		 956#ifdef CONFIG_WPS
957 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
958 wpa_s->conf->ap_scan == 2 &&
959 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
960 /* Use ap_scan==1 style network selection to find the network
961 */
962 wpa_s->scan_req = 2;
963 wpa_s->reassociate = 1;
964 wpa_supplicant_req_scan(wpa_s, 0, 0);
965 return;
966#endif /* CONFIG_WPS */
6fc6879b
JM		 967 } else {
968 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
969 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
970 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
971 }
972 wpa_supplicant_cancel_scan(wpa_s);
973
974 /* Starting new association, so clear the possibly used WPA IE from the
975 * previous association. */
976 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
977
ec5f180a
DW		 978 if (wpa_drv_set_mode(wpa_s, ssid->mode)) {
979 wpa_printf(MSG_WARNING, "Failed to set operating mode");
980 assoc_failed = 1;
981 }
982
6fc6879b
JM		 983#ifdef IEEE8021X_EAPOL
984 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
985 if (ssid->leap) {
986 if (ssid->non_leap == 0)
987 algs = AUTH_ALG_LEAP;
988 else
989 algs |= AUTH_ALG_LEAP;
990 }
991 }
992#endif /* IEEE8021X_EAPOL */
993 wpa_printf(MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
994 if (ssid->auth_alg) {
995 algs = 0;
996 if (ssid->auth_alg & WPA_AUTH_ALG_OPEN)
997 algs |= AUTH_ALG_OPEN_SYSTEM;
998 if (ssid->auth_alg & WPA_AUTH_ALG_SHARED)
999 algs |= AUTH_ALG_SHARED_KEY;
1000 if (ssid->auth_alg & WPA_AUTH_ALG_LEAP)
1001 algs |= AUTH_ALG_LEAP;
1002 wpa_printf(MSG_DEBUG, "Overriding auth_alg selection: 0x%x",
1003 algs);
1004 }
1005 wpa_drv_set_auth_alg(wpa_s, algs);
1006
1007 if (bss && (wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1008 wpa_scan_get_ie(bss, WLAN_EID_RSN)) &&
1009 (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |
1010 WPA_KEY_MGMT_FT_IEEE8021X |
56586197
JM		 1011 WPA_KEY_MGMT_FT_PSK |
1012 WPA_KEY_MGMT_IEEE8021X_SHA256 |
1013 WPA_KEY_MGMT_PSK_SHA256))) {
6fc6879b
JM		 1014 int try_opportunistic;
1015 try_opportunistic = ssid->proactive_key_caching &&
1016 (ssid->proto & WPA_PROTO_RSN);
1017 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1018 wpa_s->current_ssid,
1019 try_opportunistic) == 0)
1020 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1021 wpa_ie_len = sizeof(wpa_ie);
1022 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1023 wpa_ie, &wpa_ie_len)) {
1024 wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
1025 "management and encryption suites");
1026 return;
1027 }
1028 } else if (ssid->key_mgmt &
1029 (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X |
1030 WPA_KEY_MGMT_WPA_NONE | WPA_KEY_MGMT_FT_PSK |
56586197
JM		 1031 WPA_KEY_MGMT_FT_IEEE8021X | WPA_KEY_MGMT_PSK_SHA256 |
1032 WPA_KEY_MGMT_IEEE8021X_SHA256)) {
6fc6879b
JM		 1033 wpa_ie_len = sizeof(wpa_ie);
1034 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1035 wpa_ie, &wpa_ie_len)) {
1036 wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
1037 "management and encryption suites (no scan "
1038 "results)");
1039 return;
1040 }
ad08c363
JM		 1041#ifdef CONFIG_WPS
1042 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
b01c18a8
JM		 1043 struct wpabuf *wps_ie;
1044 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
ad08c363
JM		 1045 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1046 wpa_ie_len = wpabuf_len(wps_ie);
1047 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
24386985
JM		 1048 } else
1049 wpa_ie_len = 0;
ad08c363
JM		 1050 wpabuf_free(wps_ie);
1051 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1052#endif /* CONFIG_WPS */
6fc6879b
JM		 1053 } else {
1054 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1055 wpa_ie_len = 0;
1056 }
1057
1058 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1059 use_crypt = 1;
1060 cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher);
1061 cipher_group = cipher_suite2driver(wpa_s->group_cipher);
1062 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1063 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1064 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1065 use_crypt = 0;
1066 if (wpa_set_wep_keys(wpa_s, ssid)) {
1067 use_crypt = 1;
1068 wep_keys_set = 1;
1069 }
1070 }
ad08c363
JM		 1071 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1072 use_crypt = 0;
6fc6879b
JM		 1073
1074#ifdef IEEE8021X_EAPOL
1075 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1076 if ((ssid->eapol_flags &
1077 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1078 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1079 !wep_keys_set) {
1080 use_crypt = 0;
1081 } else {
1082 /* Assume that dynamic WEP-104 keys will be used and
1083 * set cipher suites in order for drivers to expect
1084 * encryption. */
1085 cipher_pairwise = cipher_group = CIPHER_WEP104;
1086 }
1087 }
1088#endif /* IEEE8021X_EAPOL */
1089
1090 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1091 /* Set the key before (and later after) association */
1092 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1093 }
1094
1095 wpa_drv_set_drop_unencrypted(wpa_s, use_crypt);
1096 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1097 os_memset(&params, 0, sizeof(params));
1098 if (bss) {
1099 const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
1100 params.bssid = bss->bssid;
1101 params.ssid = ie ? ie + 2 : (u8 *) "";
1102 params.ssid_len = ie ? ie[1] : 0;
1103 params.freq = bss->freq;
1104 } else {
1105 params.ssid = ssid->ssid;
1106 params.ssid_len = ssid->ssid_len;
1107 }
1108 if (ssid->mode == 1 && ssid->frequency > 0 && params.freq == 0)
1109 params.freq = ssid->frequency; /* Initial channel for IBSS */
1110 params.wpa_ie = wpa_ie;
1111 params.wpa_ie_len = wpa_ie_len;
1112 params.pairwise_suite = cipher_pairwise;
1113 params.group_suite = cipher_group;
1114 params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1115 params.auth_alg = algs;
1116 params.mode = ssid->mode;
1117 for (i = 0; i < NUM_WEP_KEYS; i++) {
1118 if (ssid->wep_key_len[i])
1119 params.wep_key[i] = ssid->wep_key[i];
1120 params.wep_key_len[i] = ssid->wep_key_len[i];
1121 }
1122 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1123
1124 if (wpa_s->driver_4way_handshake &&
1125 (params.key_mgmt_suite == KEY_MGMT_PSK ||
1126 params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1127 params.passphrase = ssid->passphrase;
1128 if (ssid->psk_set)
1129 params.psk = ssid->psk;
1130 }
1131
1132#ifdef CONFIG_IEEE80211W
1133 switch (ssid->ieee80211w) {
1134 case NO_IEEE80211W:
1135 params.mgmt_frame_protection = NO_MGMT_FRAME_PROTECTION;
1136 break;
1137 case IEEE80211W_OPTIONAL:
1138 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_OPTIONAL;
1139 break;
1140 case IEEE80211W_REQUIRED:
1141 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_REQUIRED;
1142 break;
1143 }
97d3497e
JM		 1144 if (ssid->ieee80211w != NO_IEEE80211W && bss) {
1145 const u8 *rsn = wpa_scan_get_ie(bss, WLAN_EID_RSN);
1146 struct wpa_ie_data ie;
1147 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1148 ie.capabilities &
1149 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1150 wpa_printf(MSG_DEBUG, "WPA: Selected AP supports MFP: "
1151 "require MFP");
1152 params.mgmt_frame_protection =
1153 MGMT_FRAME_PROTECTION_REQUIRED;
1154 }
1155 }
6fc6879b
JM		 1156#endif /* CONFIG_IEEE80211W */
1157
1158 if (wpa_s->use_client_mlme)
1159 ret = ieee80211_sta_associate(wpa_s, &params);
1160 else
1161 ret = wpa_drv_associate(wpa_s, &params);
1162 if (ret < 0) {
1163 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1164 "failed");
1165 /* try to continue anyway; new association will be tried again
1166 * after timeout */
1167 assoc_failed = 1;
1168 }
1169
1170 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1171 /* Set the key after the association just in case association
1172 * cleared the previously configured key. */
1173 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1174 /* No need to timeout authentication since there is no key
1175 * management. */
1176 wpa_supplicant_cancel_auth_timeout(wpa_s);
1177 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
53895c3b
JM		 1178#ifdef CONFIG_IBSS_RSN
1179 } else if (ssid->mode == IEEE80211_MODE_IBSS &&
1180 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1181 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1182 /*
1183 * RSN IBSS authentication is per-STA and we can disable the
1184 * per-BSSID authentication.
1185 */
1186 wpa_supplicant_cancel_auth_timeout(wpa_s);
1187 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1188#endif /* CONFIG_IBSS_RSN */
6fc6879b
JM		 1189 } else {
1190 /* Timeout for IEEE 802.11 authentication and association */
1d3c75b3
DW		 1191 int timeout = 60;
1192
1193 if (assoc_failed) {
1194 /* give IBSS a bit more time */
1195 timeout = ssid->mode ? 10 : 5;
1196 } else if (wpa_s->conf->ap_scan == 1) {
1197 /* give IBSS a bit more time */
1198 timeout = ssid->mode ? 20 : 10;
1199 }
6fc6879b
JM		 1200 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1201 }
1202
1203 if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1204 capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1205 /* Set static WEP keys again */
1206 wpa_set_wep_keys(wpa_s, ssid);
1207 }
1208
1209 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1210 /*
1211 * Do not allow EAP session resumption between different
1212 * network configurations.
1213 */
1214 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1215 }
1216 wpa_s->current_ssid = ssid;
1217 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1218 wpa_supplicant_initiate_eapol(wpa_s);
1219}
1220
1221
1222/**
1223 * wpa_supplicant_disassociate - Disassociate the current connection
1224 * @wpa_s: Pointer to wpa_supplicant data
1225 * @reason_code: IEEE 802.11 reason code for the disassociate frame
1226 *
1227 * This function is used to request %wpa_supplicant to disassociate with the
1228 * current AP.
1229 */
1230void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1231 int reason_code)
1232{
1233 u8 *addr = NULL;
a8e16edc 1234 if (!is_zero_ether_addr(wpa_s->bssid)) {
6fc6879b
JM		 1235 if (wpa_s->use_client_mlme)
1236 ieee80211_sta_disassociate(wpa_s, reason_code);
1237 else
1238 wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1239 addr = wpa_s->bssid;
1240 }
1241 wpa_clear_keys(wpa_s, addr);
1242 wpa_supplicant_mark_disassoc(wpa_s);
1243 wpa_s->current_ssid = NULL;
1244 wpa_sm_set_config(wpa_s->wpa, NULL);
1245 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1246}
1247
1248
1249/**
1250 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1251 * @wpa_s: Pointer to wpa_supplicant data
1252 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1253 *
1254 * This function is used to request %wpa_supplicant to disassociate with the
1255 * current AP.
1256 */
1257void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1258 int reason_code)
1259{
1260 u8 *addr = NULL;
1261 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
a8e16edc 1262 if (!is_zero_ether_addr(wpa_s->bssid)) {
6fc6879b
JM		 1263 if (wpa_s->use_client_mlme)
1264 ieee80211_sta_deauthenticate(wpa_s, reason_code);
1265 else
1266 wpa_drv_deauthenticate(wpa_s, wpa_s->bssid,
1267 reason_code);
1268 addr = wpa_s->bssid;
1269 }
1270 wpa_clear_keys(wpa_s, addr);
1271 wpa_s->current_ssid = NULL;
1272 wpa_sm_set_config(wpa_s->wpa, NULL);
1273 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1274 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1275 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1276}
1277
1278
1279static int wpa_supplicant_get_scan_results_old(struct wpa_supplicant *wpa_s)
1280{
1281#define SCAN_AP_LIMIT 128
1282 struct wpa_scan_result *results;
1283 int num, i;
1284 struct wpa_scan_results *res;
1285
1286 results = os_malloc(SCAN_AP_LIMIT * sizeof(struct wpa_scan_result));
1287 if (results == NULL) {
1288 wpa_printf(MSG_WARNING, "Failed to allocate memory for scan "
1289 "results");
1290 return -1;
1291 }
1292
1293 num = wpa_drv_get_scan_results(wpa_s, results, SCAN_AP_LIMIT);
1294 wpa_printf(MSG_DEBUG, "Scan results: %d", num);
1295 if (num < 0) {
1296 wpa_printf(MSG_DEBUG, "Failed to get scan results");
1297 os_free(results);
1298 return -1;
1299 }
1300 if (num > SCAN_AP_LIMIT) {
1301 wpa_printf(MSG_INFO, "Not enough room for all APs (%d < %d)",
1302 num, SCAN_AP_LIMIT);
1303 num = SCAN_AP_LIMIT;
1304 }
1305
1306 wpa_scan_results_free(wpa_s->scan_res);
1307 wpa_s->scan_res = NULL;
1308
1309 /* Convert old scan result data structure to the new one */
1310 res = os_zalloc(sizeof(*res));
1311 if (res == NULL) {
1312 os_free(results);
1313 return -1;
1314 }
1315 res->res = os_zalloc(num * sizeof(struct wpa_scan_res *));
1316 if (res->res == NULL) {
1317 os_free(results);
1318 os_free(res);
1319 return -1;
1320 }
1321
1322 for (i = 0; i < num; i++) {
1323 struct wpa_scan_result *bss = &results[i];
1324 struct wpa_scan_res *r;
1325 size_t ie_len;
1326 u8 *pos;
1327
1328 ie_len = 2 + bss->ssid_len + bss->rsn_ie_len + bss->wpa_ie_len;
1329 if (bss->maxrate)
1330 ie_len += 3;
1331 if (bss->mdie_present)
1332 ie_len += 5;
1333
1334 r = os_zalloc(sizeof(*r) + ie_len);
1335 if (r == NULL)
1336 break;
1337
1338 os_memcpy(r->bssid, bss->bssid, ETH_ALEN);
1339 r->freq = bss->freq;
1340 r->caps = bss->caps;
1341 r->qual = bss->qual;
1342 r->noise = bss->noise;
1343 r->level = bss->level;
1344 r->tsf = bss->tsf;
1345 r->ie_len = ie_len;
1346
1347 pos = (u8 *) (r + 1);
1348
1349 /* SSID IE */
1350 *pos++ = WLAN_EID_SSID;
1351 *pos++ = bss->ssid_len;
1352 os_memcpy(pos, bss->ssid, bss->ssid_len);
1353 pos += bss->ssid_len;
1354
1355 if (bss->maxrate) {
1356 /* Fake Supported Rate IE to include max rate */
1357 *pos++ = WLAN_EID_SUPP_RATES;
1358 *pos++ = 1;
1359 *pos++ = bss->maxrate;
1360 }
1361
1362 if (bss->rsn_ie_len) {
1363 os_memcpy(pos, bss->rsn_ie, bss->rsn_ie_len);
1364 pos += bss->rsn_ie_len;
1365 }
1366
1367 if (bss->mdie_present) {
1368 os_memcpy(pos, bss->mdie, 5);
1369 pos += 5;
1370 }
1371
1372 if (bss->wpa_ie_len) {
1373 os_memcpy(pos, bss->wpa_ie, bss->wpa_ie_len);
1374 pos += bss->wpa_ie_len;
1375 }
1376
1377 res->res[res->num++] = r;
1378 }
1379
1380 os_free(results);
1381 wpa_s->scan_res = res;
1382
1383 return 0;
1384}
1385
1386
1387/**
1388 * wpa_supplicant_get_scan_results - Get scan results
1389 * @wpa_s: Pointer to wpa_supplicant data
1390 * Returns: 0 on success, -1 on failure
1391 *
1392 * This function is request the current scan results from the driver and stores
1393 * a local copy of the results in wpa_s->scan_res.
1394 */
1395int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s)
1396{
1397 int ret;
1398
1399 if (wpa_s->use_client_mlme) {
1400 wpa_scan_results_free(wpa_s->scan_res);
1401 wpa_s->scan_res = ieee80211_sta_get_scan_results(wpa_s);
1402 if (wpa_s->scan_res == NULL) {
1403 wpa_printf(MSG_DEBUG, "Failed to get scan results");
1404 ret = -1;
1405 } else
1406 ret = 0;
1407 } else if (wpa_s->driver->get_scan_results2 == NULL)
1408 ret = wpa_supplicant_get_scan_results_old(wpa_s);
1409 else {
1410 wpa_scan_results_free(wpa_s->scan_res);
1411 wpa_s->scan_res = wpa_drv_get_scan_results2(wpa_s);
1412 if (wpa_s->scan_res == NULL) {
1413 wpa_printf(MSG_DEBUG, "Failed to get scan results");
1414 ret = -1;
1415 } else
1416 ret = 0;
1417 }
1418
1419 if (wpa_s->scan_res)
1420 wpa_scan_sort_results(wpa_s->scan_res);
1421
1422 return ret;
1423}
1424
1425
1426/**
1427 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
1428 * @wpa_s: Pointer to wpa_supplicant data
1429 * Returns: A pointer to the current network structure or %NULL on failure
1430 */
1431struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
1432{
1433 struct wpa_ssid *entry;
1434 u8 ssid[MAX_SSID_LEN];
1435 int res;
1436 size_t ssid_len;
1437 u8 bssid[ETH_ALEN];
1438 int wired;
1439
1440 if (wpa_s->use_client_mlme) {
1441 if (ieee80211_sta_get_ssid(wpa_s, ssid, &ssid_len)) {
1442 wpa_printf(MSG_WARNING, "Could not read SSID from "
1443 "MLME.");
1444 return NULL;
1445 }
1446 } else {
1447 res = wpa_drv_get_ssid(wpa_s, ssid);
1448 if (res < 0) {
1449 wpa_printf(MSG_WARNING, "Could not read SSID from "
1450 "driver.");
1451 return NULL;
1452 }
1453 ssid_len = res;
1454 }
1455
1456 if (wpa_s->use_client_mlme)
1457 os_memcpy(bssid, wpa_s->bssid, ETH_ALEN);
1458 else if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
1459 wpa_printf(MSG_WARNING, "Could not read BSSID from driver.");
1460 return NULL;
1461 }
1462
1463 wired = wpa_s->conf->ap_scan == 0 && wpa_s->driver &&
e519314e 1464 IS_WIRED(wpa_s->driver);
6fc6879b
JM		 1465
1466 entry = wpa_s->conf->ssid;
1467 while (entry) {
1468 if (!entry->disabled &&
1469 ((ssid_len == entry->ssid_len &&
1470 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
1471 (!entry->bssid_set ||
1472 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1473 return entry;
24c23d1b
JM		 1474#ifdef CONFIG_WPS
1475 if (!entry->disabled &&
1476 (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
1477 (entry->ssid == NULL || entry->ssid_len == 0) &&
1478 (!entry->bssid_set ||
1479 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
1480 return entry;
1481#endif /* CONFIG_WPS */
6fc6879b
JM		 1482 entry = entry->next;
1483 }
1484
1485 return NULL;
1486}
1487
1488
1489static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
1490 const char *name)
1491{
1492 int i;
1493
1494 if (wpa_s == NULL)
1495 return -1;
1496
1497 if (wpa_supplicant_drivers[0] == NULL) {
1498 wpa_printf(MSG_ERROR, "No driver interfaces build into "
1499 "wpa_supplicant.");
1500 return -1;
1501 }
1502
1503 if (name == NULL) {
1504 /* default to first driver in the list */
1505 wpa_s->driver = wpa_supplicant_drivers[0];
1506 return 0;
1507 }
1508
1509 for (i = 0; wpa_supplicant_drivers[i]; i++) {
1510 if (os_strcmp(name, wpa_supplicant_drivers[i]->name) == 0) {
1511 wpa_s->driver = wpa_supplicant_drivers[i];
1512 return 0;
1513 }
1514 }
1515
1516 wpa_printf(MSG_ERROR, "Unsupported driver '%s'.\n", name);
1517 return -1;
1518}
1519
1520
1521void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1522 const u8 *buf, size_t len)
1523{
1524 struct wpa_supplicant *wpa_s = ctx;
1525
1526 wpa_printf(MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
1527 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
1528
1529 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
1530 wpa_printf(MSG_DEBUG, "Ignored received EAPOL frame since "
1531 "no key management is configured");
1532 return;
1533 }
1534
1535 if (wpa_s->eapol_received == 0 &&
1536 (!wpa_s->driver_4way_handshake ||
56586197 1537 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
6fc6879b
JM		 1538 wpa_s->wpa_state != WPA_COMPLETED)) {
1539 /* Timeout for completing IEEE 802.1X and WPA authentication */
1540 wpa_supplicant_req_auth_timeout(
1541 wpa_s,
56586197 1542 (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
a6f06dab
AT		 1543 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
1544 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
6fc6879b
JM		 1545 70 : 10, 0);
1546 }
1547 wpa_s->eapol_received++;
1548
1549 if (wpa_s->countermeasures) {
1550 wpa_printf(MSG_INFO, "WPA: Countermeasures - dropped EAPOL "
1551 "packet");
1552 return;
1553 }
1554
1555 /* Source address of the incoming EAPOL frame could be compared to the
1556 * current BSSID. However, it is possible that a centralized
1557 * Authenticator could be using another MAC address than the BSSID of
1558 * an AP, so just allow any address to be used for now. The replies are
1559 * still sent to the current BSSID (if available), though. */
1560
1561 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
56586197 1562 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
6fc6879b
JM		 1563 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
1564 return;
1565 wpa_drv_poll(wpa_s);
1566 if (!wpa_s->driver_4way_handshake)
1567 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
56586197 1568 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
6fc6879b
JM		 1569 /*
1570 * Set portValid = TRUE here since we are going to skip 4-way
1571 * handshake processing which would normally set portValid. We
1572 * need this to allow the EAPOL state machines to be completed
1573 * without going through EAPOL-Key handshake.
1574 */
1575 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1576 }
1577}
1578
1579
1580void wpa_supplicant_sta_free_hw_features(struct wpa_hw_modes *hw_features,
1581 size_t num_hw_features)
1582{
1583 ieee80211_sta_free_hw_features(hw_features, num_hw_features);
1584}
1585
1586
1587void wpa_supplicant_sta_rx(void *ctx, const u8 *buf, size_t len,
1588 struct ieee80211_rx_status *rx_status)
1589{
1590 struct wpa_supplicant *wpa_s = ctx;
1591 ieee80211_sta_rx(wpa_s, buf, len, rx_status);
1592}
1593
1594
1595/**
1596 * wpa_supplicant_driver_init - Initialize driver interface parameters
1597 * @wpa_s: Pointer to wpa_supplicant data
1598 * Returns: 0 on success, -1 on failure
1599 *
1600 * This function is called to initialize driver interface parameters.
1601 * wpa_drv_init() must have been called before this function to initialize the
1602 * driver interface.
1603 */
1604int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
1605{
1606 static int interface_count = 0;
1607
1608 if (wpa_s->driver->send_eapol) {
1609 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
1610 if (addr)
1611 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
1612 } else {
1613 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
1614 wpa_drv_get_mac_addr(wpa_s),
1615 ETH_P_EAPOL,
1616 wpa_supplicant_rx_eapol, wpa_s, 0);
1617 if (wpa_s->l2 == NULL)
1618 return -1;
1619 }
1620
1621 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
1622 wpa_printf(MSG_ERROR, "Failed to get own L2 address");
1623 return -1;
1624 }
1625
1626 wpa_printf(MSG_DEBUG, "Own MAC address: " MACSTR,
1627 MAC2STR(wpa_s->own_addr));
1628
1629 if (wpa_s->bridge_ifname[0]) {
1630 wpa_printf(MSG_DEBUG, "Receiving packets from bridge interface"
1631 " '%s'", wpa_s->bridge_ifname);
1632 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
1633 wpa_s->own_addr,
1634 ETH_P_EAPOL,
1635 wpa_supplicant_rx_eapol, wpa_s,
1636 0);
1637 if (wpa_s->l2_br == NULL) {
1638 wpa_printf(MSG_ERROR, "Failed to open l2_packet "
1639 "connection for the bridge interface '%s'",
1640 wpa_s->bridge_ifname);
1641 return -1;
1642 }
1643 }
1644
1645 /* Backwards compatibility call to set_wpa() handler. This is called
1646 * only just after init and just before deinit, so these handler can be
1647 * used to implement same functionality. */
1648 if (wpa_drv_set_wpa(wpa_s, 1) < 0) {
1649 struct wpa_driver_capa capa;
1650 if (wpa_drv_get_capa(wpa_s, &capa) < 0 ||
1651 !(capa.flags & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1652 WPA_DRIVER_CAPA_KEY_MGMT_WPA2))) {
1653 wpa_printf(MSG_DEBUG, "Driver does not support WPA.");
1654 /* Continue to allow non-WPA modes to be used. */
1655 } else {
1656 wpa_printf(MSG_ERROR, "Failed to enable WPA in the "
1657 "driver.");
1658 return -1;
1659 }
1660 }
1661
1662 wpa_clear_keys(wpa_s, NULL);
1663
1664 /* Make sure that TKIP countermeasures are not left enabled (could
1665 * happen if wpa_supplicant is killed during countermeasures. */
1666 wpa_drv_set_countermeasures(wpa_s, 0);
1667
1668 wpa_drv_set_drop_unencrypted(wpa_s, 1);
1669
1670 wpa_printf(MSG_DEBUG, "RSN: flushing PMKID list in the driver");
1671 wpa_drv_flush_pmkid(wpa_s);
1672
1673 wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN;
1674 wpa_supplicant_req_scan(wpa_s, interface_count, 100000);
1675 interface_count++;
1676
1677 return 0;
1678}
1679
1680
1681static int wpa_supplicant_daemon(const char *pid_file)
1682{
1683 wpa_printf(MSG_DEBUG, "Daemonize..");
1684 return os_daemonize(pid_file);
1685}
1686
1687
1688static struct wpa_supplicant * wpa_supplicant_alloc(void)
1689{
1690 struct wpa_supplicant *wpa_s;
1691
1692 wpa_s = os_zalloc(sizeof(*wpa_s));
1693 if (wpa_s == NULL)
1694 return NULL;
1695 wpa_s->scan_req = 1;
1696
1697 return wpa_s;
1698}
1699
1700
1701static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
1702 struct wpa_interface *iface)
1703{
1704 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
1705 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
1706 iface->confname ? iface->confname : "N/A",
1707 iface->driver ? iface->driver : "default",
1708 iface->ctrl_interface ? iface->ctrl_interface : "N/A",
1709 iface->bridge_ifname ? iface->bridge_ifname : "N/A");
1710
1711 if (wpa_supplicant_set_driver(wpa_s, iface->driver) < 0) {
1712 return -1;
1713 }
1714
1715 if (iface->confname) {
1716#ifdef CONFIG_BACKEND_FILE
1717 wpa_s->confname = os_rel2abs_path(iface->confname);
1718 if (wpa_s->confname == NULL) {
1719 wpa_printf(MSG_ERROR, "Failed to get absolute path "
1720 "for configuration file '%s'.",
1721 iface->confname);
1722 return -1;
1723 }
1724 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
1725 iface->confname, wpa_s->confname);
1726#else /* CONFIG_BACKEND_FILE */
1727 wpa_s->confname = os_strdup(iface->confname);
1728#endif /* CONFIG_BACKEND_FILE */
1729 wpa_s->conf = wpa_config_read(wpa_s->confname);
1730 if (wpa_s->conf == NULL) {
1731 wpa_printf(MSG_ERROR, "Failed to read or parse "
1732 "configuration '%s'.", wpa_s->confname);
1733 return -1;
1734 }
1735
1736 /*
1737 * Override ctrl_interface and driver_param if set on command
1738 * line.
1739 */
1740 if (iface->ctrl_interface) {
1741 os_free(wpa_s->conf->ctrl_interface);
1742 wpa_s->conf->ctrl_interface =
1743 os_strdup(iface->ctrl_interface);
1744 }
1745
1746 if (iface->driver_param) {
1747 os_free(wpa_s->conf->driver_param);
1748 wpa_s->conf->driver_param =
1749 os_strdup(iface->driver_param);
1750 }
1751 } else
1752 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
1753 iface->driver_param);
1754
1755 if (wpa_s->conf == NULL) {
1756 wpa_printf(MSG_ERROR, "\nNo configuration found.");
1757 return -1;
1758 }
1759
1760 if (iface->ifname == NULL) {
1761 wpa_printf(MSG_ERROR, "\nInterface name is required.");
1762 return -1;
1763 }
1764 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
1765 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
1766 iface->ifname);
1767 return -1;
1768 }
1769 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
1770
1771 if (iface->bridge_ifname) {
1772 if (os_strlen(iface->bridge_ifname) >=
1773 sizeof(wpa_s->bridge_ifname)) {
1774 wpa_printf(MSG_ERROR, "\nToo long bridge interface "
1775 "name '%s'.", iface->bridge_ifname);
1776 return -1;
1777 }
1778 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
1779 sizeof(wpa_s->bridge_ifname));
1780 }
1781
1782 return 0;
1783}
1784
1785
1786static int wpa_supplicant_init_iface2(struct wpa_supplicant *wpa_s)
1787{
1788 const char *ifname;
1789 struct wpa_driver_capa capa;
1790
1791 wpa_printf(MSG_DEBUG, "Initializing interface (2) '%s'",
1792 wpa_s->ifname);
1793
1794 /* RSNA Supplicant Key Management - INITIALIZE */
1795 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1796 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1797
1798 /* Initialize driver interface and register driver event handler before
1799 * L2 receive handler so that association events are processed before
1800 * EAPOL-Key packets if both become available for the same select()
1801 * call. */
1802 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
1803 if (wpa_s->drv_priv == NULL) {
1804 wpa_printf(MSG_ERROR, "Failed to initialize driver interface");
1805 return -1;
1806 }
1807 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
1808 wpa_printf(MSG_ERROR, "Driver interface rejected "
1809 "driver_param '%s'", wpa_s->conf->driver_param);
1810 return -1;
1811 }
1812
1813 ifname = wpa_drv_get_ifname(wpa_s);
1814 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
1815 wpa_printf(MSG_DEBUG, "Driver interface replaced interface "
1816 "name with '%s'", ifname);
1817 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
1818 }
1819
1820 if (wpa_supplicant_init_wpa(wpa_s) < 0)
1821 return -1;
1822
1823 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
1824 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
1825 NULL);
1826 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1827
1828 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
1829 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
1830 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
1831 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1832 "dot11RSNAConfigPMKLifetime");
1833 return -1;
1834 }
1835
1836 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
1837 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
1838 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
1839 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1840 "dot11RSNAConfigPMKReauthThreshold");
1841 return -1;
1842 }
1843
1844 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
1845 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
1846 wpa_s->conf->dot11RSNAConfigSATimeout)) {
1847 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for "
1848 "dot11RSNAConfigSATimeout");
1849 return -1;
1850 }
1851
1852 if (wpa_supplicant_driver_init(wpa_s) < 0)
1853 return -1;
1854
315ce40a
JM		 1855 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
1856 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
6d158490
LR		 1857 wpa_printf(MSG_DEBUG, "Failed to set country");
1858 return -1;
1859 }
1860
6fc6879b
JM		 1861 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
1862
116654ce
JM		 1863 if (wpas_wps_init(wpa_s))
1864 return -1;
1865
6fc6879b
JM		 1866 if (wpa_supplicant_init_eapol(wpa_s) < 0)
1867 return -1;
1868 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
1869
1870 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
1871 if (wpa_s->ctrl_iface == NULL) {
1872 wpa_printf(MSG_ERROR,
1873 "Failed to initialize control interface '%s'.\n"
1874 "You may have another wpa_supplicant process "
1875 "already running or the file was\n"
1876 "left by an unclean termination of wpa_supplicant "
1877 "in which case you will need\n"
1878 "to manually remove this file before starting "
1879 "wpa_supplicant again.\n",
1880 wpa_s->conf->ctrl_interface);
1881 return -1;
1882 }
1883
1884 if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
1885 if (capa.flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
1886 wpa_s->use_client_mlme = 1;
1887 if (ieee80211_sta_init(wpa_s))
1888 return -1;
1889 }
1890 if (capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE)
1891 wpa_s->driver_4way_handshake = 1;
1892 }
1893
11ef8d35
JM		 1894#ifdef CONFIG_IBSS_RSN
1895 wpa_s->ibss_rsn = ibss_rsn_init(wpa_s);
1896 if (!wpa_s->ibss_rsn) {
1897 wpa_printf(MSG_DEBUG, "Failed to init IBSS RSN");
1898 return -1;
1899 }
1900#endif /* CONFIG_IBSS_RSN */
1901
6fc6879b
JM		 1902 return 0;
1903}
1904
1905
1906static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s)
1907{
1908 if (wpa_s->drv_priv) {
1909 wpa_supplicant_deauthenticate(wpa_s,
1910 WLAN_REASON_DEAUTH_LEAVING);
1911
1912 /* Backwards compatibility call to set_wpa() handler. This is
1913 * called only just after init and just before deinit, so these
1914 * handler can be used to implement same functionality. */
1915 if (wpa_drv_set_wpa(wpa_s, 0) < 0) {
1916 wpa_printf(MSG_ERROR, "Failed to disable WPA in the "
1917 "driver.");
1918 }
1919
1920 wpa_drv_set_drop_unencrypted(wpa_s, 0);
1921 wpa_drv_set_countermeasures(wpa_s, 0);
1922 wpa_clear_keys(wpa_s, NULL);
1923 }
1924
1925 wpas_dbus_unregister_iface(wpa_s);
1926
1927 wpa_supplicant_cleanup(wpa_s);
1928
1929 if (wpa_s->drv_priv)
1930 wpa_drv_deinit(wpa_s);
1931}
1932
1933
1934/**
1935 * wpa_supplicant_add_iface - Add a new network interface
1936 * @global: Pointer to global data from wpa_supplicant_init()
1937 * @iface: Interface configuration options
1938 * Returns: Pointer to the created interface or %NULL on failure
1939 *
1940 * This function is used to add new network interfaces for %wpa_supplicant.
1941 * This can be called before wpa_supplicant_run() to add interfaces before the
1942 * main event loop has been started. In addition, new interfaces can be added
1943 * dynamically while %wpa_supplicant is already running. This could happen,
1944 * e.g., when a hotplug network adapter is inserted.
1945 */
1946struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
1947 struct wpa_interface *iface)
1948{
1949 struct wpa_supplicant *wpa_s;
1950
1951 if (global == NULL || iface == NULL)
1952 return NULL;
1953
1954 wpa_s = wpa_supplicant_alloc();
1955 if (wpa_s == NULL)
1956 return NULL;
1957
1958 if (wpa_supplicant_init_iface(wpa_s, iface) ||
1959 wpa_supplicant_init_iface2(wpa_s)) {
1960 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
1961 iface->ifname);
1962 wpa_supplicant_deinit_iface(wpa_s);
1963 os_free(wpa_s);
1964 return NULL;
1965 }
1966
1967 wpa_s->global = global;
1968
1969 /* Register the interface with the dbus control interface */
1970 if (wpas_dbus_register_iface(wpa_s)) {
1971 wpa_supplicant_deinit_iface(wpa_s);
1972 os_free(wpa_s);
1973 return NULL;
1974 }
1975
1976 wpa_s->next = global->ifaces;
1977 global->ifaces = wpa_s;
1978
1979 wpa_printf(MSG_DEBUG, "Added interface %s", wpa_s->ifname);
1980
1981 return wpa_s;
1982}
1983
1984
1985/**
1986 * wpa_supplicant_remove_iface - Remove a network interface
1987 * @global: Pointer to global data from wpa_supplicant_init()
1988 * @wpa_s: Pointer to the network interface to be removed
1989 * Returns: 0 if interface was removed, -1 if interface was not found
1990 *
1991 * This function can be used to dynamically remove network interfaces from
1992 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
1993 * addition, this function is used to remove all remaining interfaces when
1994 * %wpa_supplicant is terminated.
1995 */
1996int wpa_supplicant_remove_iface(struct wpa_global *global,
1997 struct wpa_supplicant *wpa_s)
1998{
1999 struct wpa_supplicant *prev;
2000
2001 /* Remove interface from the global list of interfaces */
2002 prev = global->ifaces;
2003 if (prev == wpa_s) {
2004 global->ifaces = wpa_s->next;
2005 } else {
2006 while (prev && prev->next != wpa_s)
2007 prev = prev->next;
2008 if (prev == NULL)
2009 return -1;
2010 prev->next = wpa_s->next;
2011 }
2012
2013 wpa_printf(MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
2014
2015 wpa_supplicant_deinit_iface(wpa_s);
2016 os_free(wpa_s);
2017
2018 return 0;
2019}
2020
2021
2022/**
2023 * wpa_supplicant_get_iface - Get a new network interface
2024 * @global: Pointer to global data from wpa_supplicant_init()
2025 * @ifname: Interface name
2026 * Returns: Pointer to the interface or %NULL if not found
2027 */
2028struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
2029 const char *ifname)
2030{
2031 struct wpa_supplicant *wpa_s;
2032
2033 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
2034 if (os_strcmp(wpa_s->ifname, ifname) == 0)
2035 return wpa_s;
2036 }
2037 return NULL;
2038}
2039
2040
2041/**
2042 * wpa_supplicant_init - Initialize %wpa_supplicant
2043 * @params: Parameters for %wpa_supplicant
2044 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
2045 *
2046 * This function is used to initialize %wpa_supplicant. After successful
2047 * initialization, the returned data pointer can be used to add and remove
2048 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
2049 */
2050struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
2051{
2052 struct wpa_global *global;
ac305589 2053 int ret, i;
6fc6879b
JM		 2054
2055 if (params == NULL)
2056 return NULL;
2057
2058 wpa_debug_open_file(params->wpa_debug_file_path);
2059
2060 ret = eap_peer_register_methods();
2061 if (ret) {
2062 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
2063 if (ret == -2)
2064 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
2065 "the same EAP type.");
2066 return NULL;
2067 }
2068
2069 global = os_zalloc(sizeof(*global));
2070 if (global == NULL)
2071 return NULL;
2072 global->params.daemonize = params->daemonize;
2073 global->params.wait_for_monitor = params->wait_for_monitor;
2074 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
2075 if (params->pid_file)
2076 global->params.pid_file = os_strdup(params->pid_file);
2077 if (params->ctrl_interface)
2078 global->params.ctrl_interface =
2079 os_strdup(params->ctrl_interface);
2080 wpa_debug_level = global->params.wpa_debug_level =
2081 params->wpa_debug_level;
2082 wpa_debug_show_keys = global->params.wpa_debug_show_keys =
2083 params->wpa_debug_show_keys;
2084 wpa_debug_timestamp = global->params.wpa_debug_timestamp =
2085 params->wpa_debug_timestamp;
2086
2087 if (eloop_init(global)) {
2088 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
2089 wpa_supplicant_deinit(global);
2090 return NULL;
2091 }
2092
2093 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
2094 if (global->ctrl_iface == NULL) {
2095 wpa_supplicant_deinit(global);
2096 return NULL;
2097 }
2098
2099 if (global->params.dbus_ctrl_interface) {
2100 global->dbus_ctrl_iface =
2101 wpa_supplicant_dbus_ctrl_iface_init(global);
2102 if (global->dbus_ctrl_iface == NULL) {
2103 wpa_supplicant_deinit(global);
2104 return NULL;
2105 }
2106 }
2107
ac305589
JM		 2108 for (i = 0; wpa_supplicant_drivers[i]; i++)
2109 global->drv_count++;
2110 if (global->drv_count == 0) {
2111 wpa_printf(MSG_ERROR, "No drivers enabled");
2112 wpa_supplicant_deinit(global);
2113 return NULL;
2114 }
2115 global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
2116 if (global->drv_priv == NULL) {
2117 wpa_supplicant_deinit(global);
2118 return NULL;
2119 }
2120 for (i = 0; wpa_supplicant_drivers[i]; i++) {
2121 if (!wpa_supplicant_drivers[i]->global_init)
2122 continue;
2123 global->drv_priv[i] = wpa_supplicant_drivers[i]->global_init();
2124 if (global->drv_priv[i] == NULL) {
2125 wpa_printf(MSG_ERROR, "Failed to initialize driver "
2126 "'%s'", wpa_supplicant_drivers[i]->name);
2127 wpa_supplicant_deinit(global);
2128 return NULL;
2129 }
2130 }
2131
6fc6879b
JM		 2132 return global;
2133}
2134
2135
2136/**
2137 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
2138 * @global: Pointer to global data from wpa_supplicant_init()
2139 * Returns: 0 after successful event loop run, -1 on failure
2140 *
2141 * This function starts the main event loop and continues running as long as
2142 * there are any remaining events. In most cases, this function is running as
2143 * long as the %wpa_supplicant process in still in use.
2144 */
2145int wpa_supplicant_run(struct wpa_global *global)
2146{
2147 struct wpa_supplicant *wpa_s;
2148
2149 if (global->params.daemonize &&
2150 wpa_supplicant_daemon(global->params.pid_file))
2151 return -1;
2152
2153 if (global->params.wait_for_monitor) {
2154 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
2155 if (wpa_s->ctrl_iface)
2156 wpa_supplicant_ctrl_iface_wait(
2157 wpa_s->ctrl_iface);
2158 }
2159
2160 eloop_register_signal_terminate(wpa_supplicant_terminate, NULL);
2161 eloop_register_signal_reconfig(wpa_supplicant_reconfig, NULL);
2162
2163 eloop_run();
2164
2165 return 0;
2166}
2167
2168
2169/**
2170 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
2171 * @global: Pointer to global data from wpa_supplicant_init()
2172 *
2173 * This function is called to deinitialize %wpa_supplicant and to free all
2174 * allocated resources. Remaining network interfaces will also be removed.
2175 */
2176void wpa_supplicant_deinit(struct wpa_global *global)
2177{
ac305589
JM		 2178 int i;
2179
6fc6879b
JM		 2180 if (global == NULL)
2181 return;
2182
2183 while (global->ifaces)
2184 wpa_supplicant_remove_iface(global, global->ifaces);
2185
2186 if (global->ctrl_iface)
2187 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
2188 if (global->dbus_ctrl_iface)
2189 wpa_supplicant_dbus_ctrl_iface_deinit(global->dbus_ctrl_iface);
2190
2191 eap_peer_unregister_methods();
2192
ac305589
JM		 2193 for (i = 0; wpa_supplicant_drivers[i]; i++) {
2194 if (!global->drv_priv[i])
2195 continue;
2196 wpa_supplicant_drivers[i]->global_deinit(global->drv_priv[i]);
2197 }
2198 os_free(global->drv_priv);
2199
6fc6879b
JM		 2200 eloop_destroy();
2201
2202 if (global->params.pid_file) {
2203 os_daemonize_terminate(global->params.pid_file);
2204 os_free(global->params.pid_file);
2205 }
2206 os_free(global->params.ctrl_interface);
2207
2208 os_free(global);
2209 wpa_debug_close_file();
2210}
Unnamed repository; edit this file 'description' to name the repository.