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