1/* 2 * WPA Supplicant 3 * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 * 9 * Alternatively, this software may be distributed under the terms of BSD 10 * license. 11 * 12 * See README and COPYING for more details. 13 * 14 * This file implements functions for registering and unregistering 15 * %wpa_supplicant interfaces. In addition, this file contains number of 16 * functions for managing network connections. 17 */ 18 19#include "includes.h" 20 21#include "common.h" 22#include "eapol_sm.h" 23#include "eap.h" 24#include "wpa.h" 25#include "eloop.h" 26#include "wpa_supplicant.h" 27#include "config.h" 28#include "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#ifdef ANDROID 39#include <cutils/properties.h> 40#endif 41 42const char *wpa_supplicant_version = 43"wpa_supplicant v" VERSION_STR "\n" 44"Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi> and contributors"; 45 46const char *wpa_supplicant_license = 47"This program is free software. You can distribute it and/or modify it\n" 48"under the terms of the GNU General Public License version 2.\n" 49"\n" 50"Alternatively, this software may be distributed under the terms of the\n" 51"BSD license. See README and COPYING for more details.\n" 52#ifdef EAP_TLS_OPENSSL 53"\nThis product includes software developed by the OpenSSL Project\n" 54"for use in the OpenSSL Toolkit (http://www.openssl.org/)\n" 55#endif /* EAP_TLS_OPENSSL */ 56; 57 58#ifndef CONFIG_NO_STDOUT_DEBUG 59/* Long text divided into parts in order to fit in C89 strings size limits. */ 60const char *wpa_supplicant_full_license1 = 61"This program is free software; you can redistribute it and/or modify\n" 62"it under the terms of the GNU General Public License version 2 as\n" 63"published by the Free Software Foundation.\n" 64"\n" 65"This program is distributed in the hope that it will be useful,\n" 66"but WITHOUT ANY WARRANTY; without even the implied warranty of\n" 67"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" 68"GNU General Public License for more details.\n" 69"\n"; 70const char *wpa_supplicant_full_license2 = 71"You should have received a copy of the GNU General Public License\n" 72"along with this program; if not, write to the Free Software\n" 73"Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n" 74"\n" 75"Alternatively, this software may be distributed under the terms of the\n" 76"BSD license.\n" 77"\n" 78"Redistribution and use in source and binary forms, with or without\n" 79"modification, are permitted provided that the following conditions are\n" 80"met:\n" 81"\n"; 82const char *wpa_supplicant_full_license3 = 83"1. Redistributions of source code must retain the above copyright\n" 84" notice, this list of conditions and the following disclaimer.\n" 85"\n" 86"2. Redistributions in binary form must reproduce the above copyright\n" 87" notice, this list of conditions and the following disclaimer in the\n" 88" documentation and/or other materials provided with the distribution.\n" 89"\n"; 90const char *wpa_supplicant_full_license4 = 91"3. Neither the name(s) of the above-listed copyright holder(s) nor the\n" 92" names of its contributors may be used to endorse or promote products\n" 93" derived from this software without specific prior written permission.\n" 94"\n" 95"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n" 96"\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n" 97"LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n" 98"A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"; 99const char *wpa_supplicant_full_license5 = 100"OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n" 101"SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n" 102"LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n" 103"DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n" 104"THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n" 105"(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n" 106"OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" 107"\n"; 108#endif /* CONFIG_NO_STDOUT_DEBUG */ 109 110extern struct wpa_driver_ops *wpa_supplicant_drivers[]; 111 112extern int wpa_debug_level; 113extern int wpa_debug_show_keys; 114extern int wpa_debug_timestamp; 115 116static void wpa_supplicant_scan(void *eloop_ctx, void *timeout_ctx); 117 118#if defined(IEEE8021X_EAPOL) || !defined(CONFIG_NO_WPA) 119static u8 * wpa_alloc_eapol(const struct wpa_supplicant *wpa_s, u8 type, 120 const void *data, u16 data_len, 121 size_t *msg_len, void **data_pos) 122{ 123 struct ieee802_1x_hdr *hdr; 124 125 *msg_len = sizeof(*hdr) + data_len; 126 hdr = os_malloc(*msg_len); 127 if (hdr == NULL) 128 return NULL; 129 130 hdr->version = wpa_s->conf->eapol_version; 131 hdr->type = type; 132 hdr->length = host_to_be16(data_len); 133 134 if (data) 135 os_memcpy(hdr + 1, data, data_len); 136 else 137 os_memset(hdr + 1, 0, data_len); 138 139 if (data_pos) 140 *data_pos = hdr + 1; 141 142 return (u8 *) hdr; 143} 144 145 146/** 147 * wpa_ether_send - Send Ethernet frame 148 * @wpa_s: Pointer to wpa_supplicant data 149 * @dest: Destination MAC address 150 * @proto: Ethertype in host byte order 151 * @buf: Frame payload starting from IEEE 802.1X header 152 * @len: Frame payload length 153 * Returns: >=0 on success, <0 on failure 154 */ 155static int wpa_ether_send(struct wpa_supplicant *wpa_s, const u8 *dest, 156 u16 proto, const u8 *buf, size_t len) 157{ 158 if (wpa_s->l2) { 159 return l2_packet_send(wpa_s->l2, dest, proto, buf, len); 160 } 161 162 return wpa_drv_send_eapol(wpa_s, dest, proto, buf, len); 163} 164#endif /* IEEE8021X_EAPOL || !CONFIG_NO_WPA */ 165 166 167#ifdef IEEE8021X_EAPOL 168/** 169 * wpa_supplicant_eapol_send - Send IEEE 802.1X EAPOL packet to Authenticator 170 * @ctx: Pointer to wpa_supplicant data (wpa_s) 171 * @type: IEEE 802.1X packet type (IEEE802_1X_TYPE_*) 172 * @buf: EAPOL payload (after IEEE 802.1X header) 173 * @len: EAPOL payload length 174 * Returns: >=0 on success, <0 on failure 175 * 176 * This function adds Ethernet and IEEE 802.1X header and sends the EAPOL frame 177 * to the current Authenticator. 178 */ 179static int wpa_supplicant_eapol_send(void *ctx, int type, const u8 *buf, 180 size_t len) 181{ 182 struct wpa_supplicant *wpa_s = ctx; 183 u8 *msg, *dst, bssid[ETH_ALEN]; 184 size_t msglen; 185 int res; 186 187 /* TODO: could add l2_packet_sendmsg that allows fragments to avoid 188 * extra copy here */ 189 190 if (wpa_s->key_mgmt == WPA_KEY_MGMT_PSK || 191 wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) { 192 /* Current SSID is not using IEEE 802.1X/EAP, so drop possible 193 * EAPOL frames (mainly, EAPOL-Start) from EAPOL state 194 * machines. */ 195 wpa_printf(MSG_DEBUG, "WPA: drop TX EAPOL in non-IEEE 802.1X " 196 "mode (type=%d len=%lu)", type, 197 (unsigned long) len); 198 return -1; 199 } 200 201 if (pmksa_cache_get_current(wpa_s->wpa) && 202 type == IEEE802_1X_TYPE_EAPOL_START) { 203 /* Trying to use PMKSA caching - do not send EAPOL-Start frames 204 * since they will trigger full EAPOL authentication. */ 205 wpa_printf(MSG_DEBUG, "RSN: PMKSA caching - do not send " 206 "EAPOL-Start"); 207 return -1; 208 } 209 210 if (os_memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) == 0) 211 { 212 wpa_printf(MSG_DEBUG, "BSSID not set when trying to send an " 213 "EAPOL frame"); 214 if (wpa_drv_get_bssid(wpa_s, bssid) == 0 && 215 os_memcmp(bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 216 0) { 217 dst = bssid; 218 wpa_printf(MSG_DEBUG, "Using current BSSID " MACSTR 219 " from the driver as the EAPOL destination", 220 MAC2STR(dst)); 221 } else { 222 dst = wpa_s->last_eapol_src; 223 wpa_printf(MSG_DEBUG, "Using the source address of the" 224 " last received EAPOL frame " MACSTR " as " 225 "the EAPOL destination", 226 MAC2STR(dst)); 227 } 228 } else { 229 /* BSSID was already set (from (Re)Assoc event, so use it as 230 * the EAPOL destination. */ 231 dst = wpa_s->bssid; 232 } 233 234 msg = wpa_alloc_eapol(wpa_s, type, buf, len, &msglen, NULL); 235 if (msg == NULL) 236 return -1; 237 238 wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", msg, msglen); 239 res = wpa_ether_send(wpa_s, dst, ETH_P_EAPOL, msg, msglen); 240 os_free(msg); 241 return res; 242} 243 244 245/** 246 * wpa_eapol_set_wep_key - set WEP key for the driver 247 * @ctx: Pointer to wpa_supplicant data (wpa_s) 248 * @unicast: 1 = individual unicast key, 0 = broadcast key 249 * @keyidx: WEP key index (0..3) 250 * @key: Pointer to key data 251 * @keylen: Key length in bytes 252 * Returns: 0 on success or < 0 on error. 253 */ 254static int wpa_eapol_set_wep_key(void *ctx, int unicast, int keyidx, 255 const u8 *key, size_t keylen) 256{ 257 struct wpa_supplicant *wpa_s = ctx; 258 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 259 int cipher = (keylen == 5) ? WPA_CIPHER_WEP40 : 260 WPA_CIPHER_WEP104; 261 if (unicast) 262 wpa_s->pairwise_cipher = cipher; 263 else 264 wpa_s->group_cipher = cipher; 265 } 266 return wpa_drv_set_key(wpa_s, WPA_ALG_WEP, 267 unicast ? wpa_s->bssid : 268 (u8 *) "\xff\xff\xff\xff\xff\xff", 269 keyidx, unicast, (u8 *) "", 0, key, keylen); 270} 271 272 273static void wpa_supplicant_aborted_cached(void *ctx) 274{ 275 struct wpa_supplicant *wpa_s = ctx; 276 wpa_sm_aborted_cached(wpa_s->wpa); 277} 278 279#endif /* IEEE8021X_EAPOL */ 280 281 282#if defined(IEEE8021X_EAPOL) || !defined(CONFIG_NO_WPA) 283static void wpa_supplicant_set_config_blob(void *ctx, 284 struct wpa_config_blob *blob) 285{ 286 struct wpa_supplicant *wpa_s = ctx; 287 wpa_config_set_blob(wpa_s->conf, blob); 288} 289 290 291static const struct wpa_config_blob * 292wpa_supplicant_get_config_blob(void *ctx, const char *name) 293{ 294 struct wpa_supplicant *wpa_s = ctx; 295 return wpa_config_get_blob(wpa_s->conf, name); 296} 297#endif /* defined(IEEE8021X_EAPOL) || !defined(CONFIG_NO_WPA) */ 298 299 300/* Configure default/group WEP key for static WEP */ 301static int wpa_set_wep_key(void *ctx, int set_tx, int keyidx, const u8 *key, 302 size_t keylen) 303{ 304 struct wpa_supplicant *wpa_s = ctx; 305 return wpa_drv_set_key(wpa_s, WPA_ALG_WEP, 306 (u8 *) "\xff\xff\xff\xff\xff\xff", 307 keyidx, set_tx, (u8 *) "", 0, key, keylen); 308} 309 310 311static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s, 312 struct wpa_ssid *ssid) 313{ 314 u8 key[32]; 315 size_t keylen; 316 wpa_alg alg; 317 u8 seq[6] = { 0 }; 318 319 /* IBSS/WPA-None uses only one key (Group) for both receiving and 320 * sending unicast and multicast packets. */ 321 322 if (ssid->mode != IEEE80211_MODE_IBSS) { 323 wpa_printf(MSG_INFO, "WPA: Invalid mode %d (not IBSS/ad-hoc) " 324 "for WPA-None", ssid->mode); 325 return -1; 326 } 327 328 if (!ssid->psk_set) { 329 wpa_printf(MSG_INFO, "WPA: No PSK configured for WPA-None"); 330 return -1; 331 } 332 333 switch (wpa_s->group_cipher) { 334 case WPA_CIPHER_CCMP: 335 os_memcpy(key, ssid->psk, 16); 336 keylen = 16; 337 alg = WPA_ALG_CCMP; 338 break; 339 case WPA_CIPHER_TKIP: 340 /* WPA-None uses the same Michael MIC key for both TX and RX */ 341 os_memcpy(key, ssid->psk, 16 + 8); 342 os_memcpy(key + 16 + 8, ssid->psk + 16, 8); 343 keylen = 32; 344 alg = WPA_ALG_TKIP; 345 break; 346 default: 347 wpa_printf(MSG_INFO, "WPA: Invalid group cipher %d for " 348 "WPA-None", wpa_s->group_cipher); 349 return -1; 350 } 351 352 /* TODO: should actually remember the previously used seq#, both for TX 353 * and RX from each STA.. */ 354 355 return wpa_drv_set_key(wpa_s, alg, (u8 *) "\xff\xff\xff\xff\xff\xff", 356 0, 1, seq, 6, key, keylen); 357} 358 359 360#ifdef IEEE8021X_EAPOL 361static void wpa_supplicant_notify_eapol_done(void *ctx) 362{ 363 struct wpa_supplicant *wpa_s = ctx; 364 wpa_msg(wpa_s, MSG_DEBUG, "WPA: EAPOL processing complete"); 365 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X) { 366 wpa_supplicant_set_state(wpa_s, WPA_4WAY_HANDSHAKE); 367 } else { 368 wpa_supplicant_cancel_auth_timeout(wpa_s); 369 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED); 370 } 371} 372#endif /* IEEE8021X_EAPOL */ 373 374 375/** 376 * wpa_blacklist_get - Get the blacklist entry for a BSSID 377 * @wpa_s: Pointer to wpa_supplicant data 378 * @bssid: BSSID 379 * Returns: Matching blacklist entry for the BSSID or %NULL if not found 380 */ 381struct wpa_blacklist * wpa_blacklist_get(struct wpa_supplicant *wpa_s, 382 const u8 *bssid) 383{ 384 struct wpa_blacklist *e; 385 386 e = wpa_s->blacklist; 387 while (e) { 388 if (os_memcmp(e->bssid, bssid, ETH_ALEN) == 0) 389 return e; 390 e = e->next; 391 } 392 393 return NULL; 394} 395 396 397/** 398 * wpa_blacklist_add - Add an BSSID to the blacklist 399 * @wpa_s: Pointer to wpa_supplicant data 400 * @bssid: BSSID to be added to the blacklist 401 * Returns: 0 on success, -1 on failure 402 * 403 * This function adds the specified BSSID to the blacklist or increases the 404 * blacklist count if the BSSID was already listed. It should be called when 405 * an association attempt fails either due to the selected BSS rejecting 406 * association or due to timeout. 407 * 408 * This blacklist is used to force %wpa_supplicant to go through all available 409 * BSSes before retrying to associate with an BSS that rejected or timed out 410 * association. It does not prevent the listed BSS from being used; it only 411 * changes the order in which they are tried. 412 */ 413int wpa_blacklist_add(struct wpa_supplicant *wpa_s, const u8 *bssid) 414{ 415 struct wpa_blacklist *e; 416 417 e = wpa_blacklist_get(wpa_s, bssid); 418 if (e) { 419 e->count++; 420 wpa_printf(MSG_DEBUG, "BSSID " MACSTR " blacklist count " 421 "incremented to %d", 422 MAC2STR(bssid), e->count); 423 return 0; 424 } 425 426 e = os_zalloc(sizeof(*e)); 427 if (e == NULL) 428 return -1; 429 os_memcpy(e->bssid, bssid, ETH_ALEN); 430 e->count = 1; 431 e->next = wpa_s->blacklist; 432 wpa_s->blacklist = e; 433 wpa_printf(MSG_DEBUG, "Added BSSID " MACSTR " into blacklist", 434 MAC2STR(bssid)); 435 436 return 0; 437} 438 439 440static int wpa_blacklist_del(struct wpa_supplicant *wpa_s, const u8 *bssid) 441{ 442 struct wpa_blacklist *e, *prev = NULL; 443 444 e = wpa_s->blacklist; 445 while (e) { 446 if (os_memcmp(e->bssid, bssid, ETH_ALEN) == 0) { 447 if (prev == NULL) { 448 wpa_s->blacklist = e->next; 449 } else { 450 prev->next = e->next; 451 } 452 wpa_printf(MSG_DEBUG, "Removed BSSID " MACSTR " from " 453 "blacklist", MAC2STR(bssid)); 454 os_free(e); 455 return 0; 456 } 457 prev = e; 458 e = e->next; 459 } 460 return -1; 461} 462 463 464/** 465 * wpa_blacklist_clear - Clear the blacklist of all entries 466 * @wpa_s: Pointer to wpa_supplicant data 467 */ 468void wpa_blacklist_clear(struct wpa_supplicant *wpa_s) 469{ 470 struct wpa_blacklist *e, *prev; 471 472 e = wpa_s->blacklist; 473 wpa_s->blacklist = NULL; 474 while (e) { 475 prev = e; 476 e = e->next; 477 wpa_printf(MSG_DEBUG, "Removed BSSID " MACSTR " from " 478 "blacklist (clear)", MAC2STR(prev->bssid)); 479 os_free(prev); 480 } 481} 482 483 484/** 485 * wpa_supplicant_req_scan - Schedule a scan for neighboring access points 486 * @wpa_s: Pointer to wpa_supplicant data 487 * @sec: Number of seconds after which to scan 488 * @usec: Number of microseconds after which to scan 489 * 490 * This function is used to schedule a scan for neighboring access points after 491 * the specified time. 492 */ 493void wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec) 494{ 495#ifndef ANDROID 496 /* If there's at least one network that should be specifically scanned 497 * then don't cancel the scan and reschedule. Some drivers do 498 * background scanning which generates frequent scan results, and that 499 * causes the specific SSID scan to get continually pushed back and 500 * never happen, which causes hidden APs to never get probe-scanned. 501 */ 502 if (eloop_is_timeout_registered(wpa_supplicant_scan, wpa_s, NULL) && 503 wpa_s->conf->ap_scan == 1) { 504 struct wpa_ssid *ssid = wpa_s->conf->ssid; 505 506 while (ssid) { 507 if (!ssid->disabled && ssid->scan_ssid) 508 break; 509 ssid = ssid->next; 510 } 511 if (ssid) { 512 wpa_msg(wpa_s, MSG_DEBUG, "Not rescheduling scan to " 513 "ensure that specific SSID scans occur"); 514 return; 515 } 516 } 517#endif 518 519 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan request: %d sec %d usec", 520 sec, usec); 521 eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL); 522 eloop_register_timeout(sec, usec, wpa_supplicant_scan, wpa_s, NULL); 523} 524 525 526/** 527 * wpa_supplicant_cancel_scan - Cancel a scheduled scan request 528 * @wpa_s: Pointer to wpa_supplicant data 529 * 530 * This function is used to cancel a scan request scheduled with 531 * wpa_supplicant_req_scan(). 532 */ 533void wpa_supplicant_cancel_scan(struct wpa_supplicant *wpa_s) 534{ 535 wpa_msg(wpa_s, MSG_DEBUG, "Cancelling scan request"); 536 eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL); 537 wpa_s->scan_ongoing = 0; 538} 539 540 541static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx) 542{ 543 struct wpa_supplicant *wpa_s = eloop_ctx; 544 const u8 *bssid = wpa_s->bssid; 545 if (os_memcmp(bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) == 0) 546 bssid = wpa_s->pending_bssid; 547 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.", 548 MAC2STR(bssid)); 549 wpa_blacklist_add(wpa_s, bssid); 550 wpa_sm_notify_disassoc(wpa_s->wpa); 551 wpa_supplicant_disassociate(wpa_s, REASON_DEAUTH_LEAVING); 552 wpa_s->reassociate = 1; 553 wpa_supplicant_req_scan(wpa_s, 0, 0); 554} 555 556 557/** 558 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication 559 * @wpa_s: Pointer to wpa_supplicant data 560 * @sec: Number of seconds after which to time out authentication 561 * @usec: Number of microseconds after which to time out authentication 562 * 563 * This function is used to schedule a timeout for the current authentication 564 * attempt. 565 */ 566void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s, 567 int sec, int usec) 568{ 569 if (wpa_s->conf && wpa_s->conf->ap_scan == 0 && 570 wpa_s->driver && os_strcmp(wpa_s->driver->name, "wired") == 0) 571 return; 572 573 wpa_msg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec " 574 "%d usec", sec, usec); 575 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 576 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL); 577} 578 579 580/** 581 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout 582 * @wpa_s: Pointer to wpa_supplicant data 583 * 584 * This function is used to cancel authentication timeout scheduled with 585 * wpa_supplicant_req_auth_timeout() and it is called when authentication has 586 * been completed. 587 */ 588void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s) 589{ 590 wpa_msg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout"); 591 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 592 wpa_blacklist_del(wpa_s, wpa_s->bssid); 593} 594 595 596/** 597 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine 598 * @wpa_s: Pointer to wpa_supplicant data 599 * 600 * This function is used to configure EAPOL state machine based on the selected 601 * authentication mode. 602 */ 603void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s) 604{ 605#ifdef IEEE8021X_EAPOL 606 struct eapol_config eapol_conf; 607 struct wpa_ssid *ssid = wpa_s->current_ssid; 608 609 if (wpa_s->key_mgmt == WPA_KEY_MGMT_PSK) { 610 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE); 611 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE); 612 } 613 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 614 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) 615 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized); 616 else 617 eapol_sm_notify_portControl(wpa_s->eapol, Auto); 618 619 os_memset(&eapol_conf, 0, sizeof(eapol_conf)); 620 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 621 eapol_conf.accept_802_1x_keys = 1; 622 eapol_conf.required_keys = 0; 623 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) { 624 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST; 625 } 626 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) { 627 eapol_conf.required_keys |= 628 EAPOL_REQUIRE_KEY_BROADCAST; 629 } 630 631 if (wpa_s->conf && wpa_s->driver && 632 os_strcmp(wpa_s->driver->name, "wired") == 0) { 633 eapol_conf.required_keys = 0; 634 } 635 } 636 if (wpa_s->conf) 637 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth; 638 eapol_conf.workaround = ssid->eap_workaround; 639 eapol_conf.eap_disabled = wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X && 640 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA; 641 eapol_sm_notify_config(wpa_s->eapol, ssid, &eapol_conf); 642#endif /* IEEE8021X_EAPOL */ 643} 644 645 646/** 647 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode 648 * @wpa_s: Pointer to wpa_supplicant data 649 * @ssid: Configuration data for the network 650 * 651 * This function is used to configure WPA state machine and related parameters 652 * to a mode where WPA is not enabled. This is called as part of the 653 * authentication configuration when the selected network does not use WPA. 654 */ 655void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s, 656 struct wpa_ssid *ssid) 657{ 658 int i; 659 660 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) 661 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA; 662 else 663 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE; 664 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0); 665 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0); 666 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); 667 wpa_s->pairwise_cipher = WPA_CIPHER_NONE; 668 wpa_s->group_cipher = WPA_CIPHER_NONE; 669 wpa_s->mgmt_group_cipher = 0; 670 671 for (i = 0; i < NUM_WEP_KEYS; i++) { 672 if (ssid->wep_key_len[i] > 5) { 673 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104; 674 wpa_s->group_cipher = WPA_CIPHER_WEP104; 675 break; 676 } else if (ssid->wep_key_len[i] > 0) { 677 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40; 678 wpa_s->group_cipher = WPA_CIPHER_WEP40; 679 break; 680 } 681 } 682 683 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt); 684 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE, 685 wpa_s->pairwise_cipher); 686 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher); 687#ifdef CONFIG_IEEE80211W 688 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP, 689 wpa_s->mgmt_group_cipher); 690#endif /* CONFIG_IEEE80211W */ 691 692 pmksa_cache_clear_current(wpa_s->wpa); 693} 694 695 696static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s) 697{ 698 scard_deinit(wpa_s->scard); 699 wpa_s->scard = NULL; 700 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL); 701 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL); 702 l2_packet_deinit(wpa_s->l2); 703 wpa_s->l2 = NULL; 704 if (wpa_s->l2_br) { 705 l2_packet_deinit(wpa_s->l2_br); 706 wpa_s->l2_br = NULL; 707 } 708 709 if (wpa_s->ctrl_iface) { 710 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface); 711 wpa_s->ctrl_iface = NULL; 712 } 713 if (wpa_s->conf != NULL) { 714 wpa_config_free(wpa_s->conf); 715 wpa_s->conf = NULL; 716 } 717 718 os_free(wpa_s->confname); 719 wpa_s->confname = NULL; 720 721 wpa_sm_set_eapol(wpa_s->wpa, NULL); 722 eapol_sm_deinit(wpa_s->eapol); 723 wpa_s->eapol = NULL; 724 725 rsn_preauth_deinit(wpa_s->wpa); 726 727 pmksa_candidate_free(wpa_s->wpa); 728 wpa_sm_deinit(wpa_s->wpa); 729 wpa_s->wpa = NULL; 730 wpa_blacklist_clear(wpa_s); 731 732 os_free(wpa_s->scan_results); 733 wpa_s->scan_results = NULL; 734 wpa_s->num_scan_results = 0; 735 736 wpa_supplicant_cancel_scan(wpa_s); 737 wpa_supplicant_cancel_auth_timeout(wpa_s); 738 739 ieee80211_sta_deinit(wpa_s); 740} 741 742 743/** 744 * wpa_clear_keys - Clear keys configured for the driver 745 * @wpa_s: Pointer to wpa_supplicant data 746 * @addr: Previously used BSSID or %NULL if not available 747 * 748 * This function clears the encryption keys that has been previously configured 749 * for the driver. 750 */ 751void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr) 752{ 753 u8 *bcast = (u8 *) "\xff\xff\xff\xff\xff\xff"; 754 755 if (wpa_s->keys_cleared) { 756 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have 757 * timing issues with keys being cleared just before new keys 758 * are set or just after association or something similar. This 759 * shows up in group key handshake failing often because of the 760 * client not receiving the first encrypted packets correctly. 761 * Skipping some of the extra key clearing steps seems to help 762 * in completing group key handshake more reliably. */ 763 wpa_printf(MSG_DEBUG, "No keys have been configured - " 764 "skip key clearing"); 765 return; 766 } 767 768 /* MLME-DELETEKEYS.request */ 769 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 0, 0, NULL, 0, NULL, 0); 770 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 1, 0, NULL, 0, NULL, 0); 771 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 2, 0, NULL, 0, NULL, 0); 772 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, bcast, 3, 0, NULL, 0, NULL, 0); 773 if (addr) { 774 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL, 775 0); 776 /* MLME-SETPROTECTION.request(None) */ 777 wpa_drv_mlme_setprotection( 778 wpa_s, addr, 779 MLME_SETPROTECTION_PROTECT_TYPE_NONE, 780 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE); 781 } 782 wpa_s->keys_cleared = 1; 783} 784 785 786/** 787 * wpa_supplicant_state_txt - Get the connection state name as a text string 788 * @state: State (wpa_state; WPA_*) 789 * Returns: The state name as a printable text string 790 */ 791const char * wpa_supplicant_state_txt(int state) 792{ 793 switch (state) { 794 case WPA_DISCONNECTED: 795 return "DISCONNECTED"; 796 case WPA_INACTIVE: 797 return "INACTIVE"; 798 case WPA_SCANNING: 799 return "SCANNING"; 800 case WPA_ASSOCIATING: 801 return "ASSOCIATING"; 802 case WPA_ASSOCIATED: 803 return "ASSOCIATED"; 804 case WPA_4WAY_HANDSHAKE: 805 return "4WAY_HANDSHAKE"; 806 case WPA_GROUP_HANDSHAKE: 807 return "GROUP_HANDSHAKE"; 808 case WPA_COMPLETED: 809 return "COMPLETED"; 810 default: 811 return "UNKNOWN"; 812 } 813} 814 815 816/** 817 * wpa_supplicant_set_state - Set current connection state 818 * @wpa_s: Pointer to wpa_supplicant data 819 * @state: The new connection state 820 * 821 * This function is called whenever the connection state changes, e.g., 822 * association is completed for WPA/WPA2 4-Way Handshake is started. 823 */ 824void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, wpa_states state) 825{ 826#ifdef ANDROID 827 int network_id = -1; 828 if (wpa_s && wpa_s->current_ssid) { 829 network_id = wpa_s->current_ssid->id; 830 } 831 wpa_states reported_state = state; 832 if (state == WPA_DISCONNECTED && wpa_s->disconnected) { 833 reported_state = WPA_IDLE; 834 } 835#endif 836 wpa_printf(MSG_DEBUG, "State: %s -> %s", 837 wpa_supplicant_state_txt(wpa_s->wpa_state), 838 wpa_supplicant_state_txt(state)); 839 840 wpa_supplicant_dbus_notify_state_change(wpa_s, state, 841 wpa_s->wpa_state); 842#ifdef ANDROID 843 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_STATE_CHANGE "id=%d state=%d", 844 network_id, reported_state); /* Dm: */ 845#endif 846 if (state == WPA_COMPLETED && wpa_s->new_connection) { 847#if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG) 848 struct wpa_ssid *ssid = wpa_s->current_ssid; 849 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to " 850 MACSTR " completed %s [id=%d id_str=%s]", 851 MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ? 852 "(reauth)" : "(auth)", 853 ssid ? ssid->id : -1, 854 ssid && ssid->id_str ? ssid->id_str : ""); 855#endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */ 856 wpa_s->new_connection = 0; 857 wpa_s->reassociated_connection = 1; 858 wpa_drv_set_operstate(wpa_s, 1); 859 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING || 860 state == WPA_ASSOCIATED) { 861 wpa_s->new_connection = 1; 862 wpa_drv_set_operstate(wpa_s, 0); 863 } 864 wpa_s->wpa_state = state; 865} 866 867 868/** 869 * wpa_supplicant_get_state - Get the connection state 870 * @wpa_s: Pointer to wpa_supplicant data 871 * Returns: The current connection state (WPA_*) 872 */ 873wpa_states wpa_supplicant_get_state(struct wpa_supplicant *wpa_s) 874{ 875 return wpa_s->wpa_state; 876} 877 878 879static void wpa_supplicant_terminate(int sig, void *eloop_ctx, 880 void *signal_ctx) 881{ 882 struct wpa_global *global = eloop_ctx; 883 struct wpa_supplicant *wpa_s; 884 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 885 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d " 886 "received", sig); 887 } 888 eloop_terminate(); 889} 890 891 892static void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s) 893{ 894 wpa_s->pairwise_cipher = 0; 895 wpa_s->group_cipher = 0; 896 wpa_s->mgmt_group_cipher = 0; 897 wpa_s->key_mgmt = 0; 898 wpa_s->wpa_state = WPA_DISCONNECTED; 899} 900 901 902/** 903 * wpa_supplicant_reload_configuration - Reload configuration data 904 * @wpa_s: Pointer to wpa_supplicant data 905 * Returns: 0 on success or -1 if configuration parsing failed 906 * 907 * This function can be used to request that the configuration data is reloaded 908 * (e.g., after configuration file change). This function is reloading 909 * configuration only for one interface, so this may need to be called multiple 910 * times if %wpa_supplicant is controlling multiple interfaces and all 911 * interfaces need reconfiguration. 912 */ 913int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s) 914{ 915 struct wpa_config *conf; 916 int reconf_ctrl; 917 if (wpa_s->confname == NULL) 918 return -1; 919 conf = wpa_config_read(wpa_s->confname); 920 if (conf == NULL) { 921 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration " 922 "file '%s' - exiting", wpa_s->confname); 923 return -1; 924 } 925 926 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface 927 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface && 928 os_strcmp(conf->ctrl_interface, 929 wpa_s->conf->ctrl_interface) != 0); 930 931 if (reconf_ctrl && wpa_s->ctrl_iface) { 932 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface); 933 wpa_s->ctrl_iface = NULL; 934 } 935 936 eapol_sm_invalidate_cached_session(wpa_s->eapol); 937 wpa_s->current_ssid = NULL; 938 /* 939 * TODO: should notify EAPOL SM about changes in opensc_engine_path, 940 * pkcs11_engine_path, pkcs11_module_path. 941 */ 942 if (wpa_s->key_mgmt == WPA_KEY_MGMT_PSK) { 943 /* 944 * Clear forced success to clear EAP state for next 945 * authentication. 946 */ 947 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE); 948 } 949 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 950 wpa_sm_set_config(wpa_s->wpa, NULL); 951 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth); 952 rsn_preauth_deinit(wpa_s->wpa); 953 wpa_config_free(wpa_s->conf); 954 wpa_s->conf = conf; 955 if (reconf_ctrl) 956 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s); 957 958 wpa_supplicant_clear_status(wpa_s); 959 wpa_s->reassociate = 1; 960#ifdef ANDROID 961 wpa_supplicant_req_scan(wpa_s, 2, 0); 962#else 963 wpa_supplicant_req_scan(wpa_s, 0, 0); 964#endif 965 wpa_msg(wpa_s, MSG_DEBUG, "Reconfiguration completed"); 966 return 0; 967} 968 969 970static void wpa_supplicant_reconfig(int sig, void *eloop_ctx, 971 void *signal_ctx) 972{ 973 struct wpa_global *global = eloop_ctx; 974 struct wpa_supplicant *wpa_s; 975 wpa_printf(MSG_DEBUG, "Signal %d received - reconfiguring", sig); 976 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 977 if (wpa_supplicant_reload_configuration(wpa_s) < 0) { 978 eloop_terminate(); 979 } 980 } 981} 982 983 984static void wpa_supplicant_gen_assoc_event(struct wpa_supplicant *wpa_s) 985{ 986 struct wpa_ssid *ssid; 987 union wpa_event_data data; 988 989 ssid = wpa_supplicant_get_ssid(wpa_s); 990 if (ssid == NULL) 991 return; 992 993 if (wpa_s->current_ssid == NULL) 994 wpa_s->current_ssid = ssid; 995 wpa_supplicant_initiate_eapol(wpa_s); 996 wpa_printf(MSG_DEBUG, "Already associated with a configured network - " 997 "generating associated event"); 998 os_memset(&data, 0, sizeof(data)); 999 wpa_supplicant_event(wpa_s, EVENT_ASSOC, &data); 1000} 1001 1002 1003static void wpa_supplicant_scan(void *eloop_ctx, void *timeout_ctx) 1004{ 1005 struct wpa_supplicant *wpa_s = eloop_ctx; 1006 struct wpa_ssid *ssid; 1007 int enabled, scan_req = 0, ret; 1008 1009 if (wpa_s->disconnected && !wpa_s->scan_req) 1010 return; 1011 1012 enabled = 0; 1013 ssid = wpa_s->conf->ssid; 1014 while (ssid) { 1015 if (!ssid->disabled) { 1016 enabled++; 1017 break; 1018 } 1019 ssid = ssid->next; 1020 } 1021 if (!enabled && !wpa_s->scan_req) { 1022 wpa_printf(MSG_DEBUG, "No enabled networks - do not scan"); 1023 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE); 1024 return; 1025 } 1026 scan_req = wpa_s->scan_req; 1027 wpa_s->scan_req = 0; 1028 1029 if (wpa_s->conf->ap_scan != 0 && 1030 wpa_s->driver && os_strcmp(wpa_s->driver->name, "wired") == 0) { 1031 wpa_printf(MSG_DEBUG, "Using wired driver - overriding " 1032 "ap_scan configuration"); 1033 wpa_s->conf->ap_scan = 0; 1034 } 1035 1036 if (wpa_s->conf->ap_scan == 0) { 1037 wpa_supplicant_gen_assoc_event(wpa_s); 1038 return; 1039 } 1040 1041 if (wpa_s->wpa_state == WPA_DISCONNECTED || 1042 wpa_s->wpa_state == WPA_INACTIVE) 1043 wpa_supplicant_set_state(wpa_s, WPA_SCANNING); 1044 1045 ssid = wpa_s->conf->ssid; 1046 if (wpa_s->prev_scan_ssid != BROADCAST_SSID_SCAN) { 1047 while (ssid) { 1048 if (ssid == wpa_s->prev_scan_ssid) { 1049 ssid = ssid->next; 1050 break; 1051 } 1052 ssid = ssid->next; 1053 } 1054 } 1055 while (ssid) { 1056 if (!ssid->disabled && 1057 (ssid->scan_ssid || wpa_s->conf->ap_scan == 2)) 1058 break; 1059 ssid = ssid->next; 1060 } 1061 1062 if (scan_req != 2 && wpa_s->conf->ap_scan == 2) { 1063 /* 1064 * ap_scan=2 mode - try to associate with each SSID instead of 1065 * scanning for each scan_ssid=1 network. 1066 */ 1067 if (ssid == NULL) { 1068 wpa_printf(MSG_DEBUG, "wpa_supplicant_scan: Reached " 1069 "end of scan list - go back to beginning"); 1070 wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN; 1071 wpa_supplicant_req_scan(wpa_s, 0, 0); 1072 return; 1073 } 1074 if (ssid->next) { 1075 /* Continue from the next SSID on the next attempt. */ 1076 wpa_s->prev_scan_ssid = ssid; 1077 } else { 1078 /* Start from the beginning of the SSID list. */ 1079 wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN; 1080 } 1081 wpa_supplicant_associate(wpa_s, NULL, ssid); 1082 return; 1083 } 1084 1085 wpa_printf(MSG_DEBUG, "Starting AP scan (%s SSID)", 1086 ssid ? "specific": "broadcast"); 1087 if (ssid) { 1088 wpa_hexdump_ascii(MSG_DEBUG, "Scan SSID", 1089 ssid->ssid, ssid->ssid_len); 1090 wpa_s->prev_scan_ssid = ssid; 1091 } else 1092 wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN; 1093 1094 if (wpa_s->scan_res_tried == 0 && wpa_s->conf->ap_scan == 1) { 1095 wpa_s->scan_res_tried++; 1096 wpa_s->scan_req = scan_req; 1097 wpa_printf(MSG_DEBUG, "Trying to get current scan results " 1098 "first without requesting a new scan to speed up " 1099 "initial association"); 1100 wpa_supplicant_event(wpa_s, EVENT_SCAN_RESULTS, NULL); 1101 return; 1102 } 1103 1104 if (wpa_s->use_client_mlme) { 1105 ret = ieee80211_sta_req_scan(wpa_s, ssid ? ssid->ssid : NULL, 1106 ssid ? ssid->ssid_len : 0); 1107 } else { 1108 ret = wpa_drv_scan(wpa_s, ssid ? ssid->ssid : NULL, 1109 ssid ? ssid->ssid_len : 0); 1110 } 1111 if (ret) { 1112 wpa_printf(MSG_WARNING, "Failed to initiate AP scan."); 1113 wpa_supplicant_req_scan(wpa_s, 10, 0); 1114 } 1115 else 1116 wpa_s->scan_ongoing = 1; 1117} 1118 1119 1120static wpa_cipher cipher_suite2driver(int cipher) 1121{ 1122 switch (cipher) { 1123 case WPA_CIPHER_NONE: 1124 return CIPHER_NONE; 1125 case WPA_CIPHER_WEP40: 1126 return CIPHER_WEP40; 1127 case WPA_CIPHER_WEP104: 1128 return CIPHER_WEP104; 1129 case WPA_CIPHER_CCMP: 1130 return CIPHER_CCMP; 1131 case WPA_CIPHER_TKIP: 1132 default: 1133 return CIPHER_TKIP; 1134 } 1135} 1136 1137 1138static wpa_key_mgmt key_mgmt2driver(int key_mgmt) 1139{ 1140 switch (key_mgmt) { 1141 case WPA_KEY_MGMT_NONE: 1142 return KEY_MGMT_NONE; 1143 case WPA_KEY_MGMT_IEEE8021X_NO_WPA: 1144 return KEY_MGMT_802_1X_NO_WPA; 1145 case WPA_KEY_MGMT_IEEE8021X: 1146 return KEY_MGMT_802_1X; 1147 case WPA_KEY_MGMT_WPA_NONE: 1148 return KEY_MGMT_WPA_NONE; 1149 case WPA_KEY_MGMT_PSK: 1150 default: 1151 return KEY_MGMT_PSK; 1152 } 1153} 1154 1155 1156static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s, 1157 struct wpa_ssid *ssid, 1158 struct wpa_ie_data *ie) 1159{ 1160 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie); 1161 if (ret) { 1162 if (ret == -2) { 1163 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE " 1164 "from association info"); 1165 } 1166 return -1; 1167 } 1168 1169 wpa_printf(MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set cipher " 1170 "suites"); 1171 if (!(ie->group_cipher & ssid->group_cipher)) { 1172 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group " 1173 "cipher 0x%x (mask 0x%x) - reject", 1174 ie->group_cipher, ssid->group_cipher); 1175 return -1; 1176 } 1177 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) { 1178 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise " 1179 "cipher 0x%x (mask 0x%x) - reject", 1180 ie->pairwise_cipher, ssid->pairwise_cipher); 1181 return -1; 1182 } 1183 if (!(ie->key_mgmt & ssid->key_mgmt)) { 1184 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key " 1185 "management 0x%x (mask 0x%x) - reject", 1186 ie->key_mgmt, ssid->key_mgmt); 1187 return -1; 1188 } 1189 1190#ifdef CONFIG_IEEE80211W 1191 if (!(ie->capabilities & WPA_CAPABILITY_MGMT_FRAME_PROTECTION) && 1192 ssid->ieee80211w == IEEE80211W_REQUIRED) { 1193 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP " 1194 "that does not support management frame protection - " 1195 "reject"); 1196 return -1; 1197 } 1198#endif /* CONFIG_IEEE80211W */ 1199 1200 return 0; 1201} 1202 1203 1204/** 1205 * wpa_supplicant_set_suites - Set authentication and encryption parameters 1206 * @wpa_s: Pointer to wpa_supplicant data 1207 * @bss: Scan results for the selected BSS, or %NULL if not available 1208 * @ssid: Configuration data for the selected network 1209 * @wpa_ie: Buffer for the WPA/RSN IE 1210 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the 1211 * used buffer length in case the functions returns success. 1212 * Returns: 0 on success or -1 on failure 1213 * 1214 * This function is used to configure authentication and encryption parameters 1215 * based on the network configuration and scan result for the selected BSS (if 1216 * available). 1217 */ 1218int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s, 1219 struct wpa_scan_result *bss, 1220 struct wpa_ssid *ssid, 1221 u8 *wpa_ie, size_t *wpa_ie_len) 1222{ 1223 struct wpa_ie_data ie; 1224 int sel, proto; 1225 1226 if (bss && bss->rsn_ie_len && (ssid->proto & WPA_PROTO_RSN) && 1227 wpa_parse_wpa_ie(bss->rsn_ie, bss->rsn_ie_len, &ie) == 0 && 1228 (ie.group_cipher & ssid->group_cipher) && 1229 (ie.pairwise_cipher & ssid->pairwise_cipher) && 1230 (ie.key_mgmt & ssid->key_mgmt)) { 1231 wpa_msg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0"); 1232 proto = WPA_PROTO_RSN; 1233 } else if (bss && bss->wpa_ie_len && (ssid->proto & WPA_PROTO_WPA) && 1234 wpa_parse_wpa_ie(bss->wpa_ie, bss->wpa_ie_len, &ie) == 0 && 1235 (ie.group_cipher & ssid->group_cipher) && 1236 (ie.pairwise_cipher & ssid->pairwise_cipher) && 1237 (ie.key_mgmt & ssid->key_mgmt)) { 1238 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0"); 1239 proto = WPA_PROTO_WPA; 1240 } else if (bss) { 1241 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN"); 1242 return -1; 1243 } else { 1244 if (ssid->proto & WPA_PROTO_RSN) 1245 proto = WPA_PROTO_RSN; 1246 else 1247 proto = WPA_PROTO_WPA; 1248 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) { 1249 os_memset(&ie, 0, sizeof(ie)); 1250 ie.group_cipher = ssid->group_cipher; 1251 ie.pairwise_cipher = ssid->pairwise_cipher; 1252 ie.key_mgmt = ssid->key_mgmt; 1253#ifdef CONFIG_IEEE80211W 1254 ie.mgmt_group_cipher = 1255 ssid->ieee80211w != NO_IEEE80211W ? 1256 WPA_CIPHER_AES_128_CMAC : 0; 1257#endif /* CONFIG_IEEE80211W */ 1258 wpa_printf(MSG_DEBUG, "WPA: Set cipher suites based " 1259 "on configuration"); 1260 } else 1261 proto = ie.proto; 1262 } 1263 1264 wpa_printf(MSG_DEBUG, "WPA: Selected cipher suites: group %d " 1265 "pairwise %d key_mgmt %d proto %d", 1266 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto); 1267#ifdef CONFIG_IEEE80211W 1268 if (ssid->ieee80211w) { 1269 wpa_printf(MSG_DEBUG, "WPA: Selected mgmt group cipher %d", 1270 ie.mgmt_group_cipher); 1271 } 1272#endif /* CONFIG_IEEE80211W */ 1273 1274 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto); 1275 1276 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss ? bss->wpa_ie : NULL, 1277 bss ? bss->wpa_ie_len : 0) || 1278 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss ? bss->rsn_ie : NULL, 1279 bss ? bss->rsn_ie_len : 0)) 1280 return -1; 1281 1282 sel = ie.group_cipher & ssid->group_cipher; 1283 if (sel & WPA_CIPHER_CCMP) { 1284 wpa_s->group_cipher = WPA_CIPHER_CCMP; 1285 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP"); 1286 } else if (sel & WPA_CIPHER_TKIP) { 1287 wpa_s->group_cipher = WPA_CIPHER_TKIP; 1288 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP"); 1289 } else if (sel & WPA_CIPHER_WEP104) { 1290 wpa_s->group_cipher = WPA_CIPHER_WEP104; 1291 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104"); 1292 } else if (sel & WPA_CIPHER_WEP40) { 1293 wpa_s->group_cipher = WPA_CIPHER_WEP40; 1294 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40"); 1295 } else { 1296 wpa_printf(MSG_WARNING, "WPA: Failed to select group cipher."); 1297 return -1; 1298 } 1299 1300 sel = ie.pairwise_cipher & ssid->pairwise_cipher; 1301 if (sel & WPA_CIPHER_CCMP) { 1302 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP; 1303 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP"); 1304 } else if (sel & WPA_CIPHER_TKIP) { 1305 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP; 1306 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP"); 1307 } else if (sel & WPA_CIPHER_NONE) { 1308 wpa_s->pairwise_cipher = WPA_CIPHER_NONE; 1309 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE"); 1310 } else { 1311 wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise " 1312 "cipher."); 1313 return -1; 1314 } 1315 1316 sel = ie.key_mgmt & ssid->key_mgmt; 1317 if (sel & WPA_KEY_MGMT_IEEE8021X) { 1318 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X; 1319 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X"); 1320 } else if (sel & WPA_KEY_MGMT_PSK) { 1321 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK; 1322 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK"); 1323 } else if (sel & WPA_KEY_MGMT_WPA_NONE) { 1324 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE; 1325 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE"); 1326 } else { 1327 wpa_printf(MSG_WARNING, "WPA: Failed to select authenticated " 1328 "key management type."); 1329 return -1; 1330 } 1331 1332 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt); 1333 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE, 1334 wpa_s->pairwise_cipher); 1335 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher); 1336 1337#ifdef CONFIG_IEEE80211W 1338 sel = ie.mgmt_group_cipher; 1339 if (ssid->ieee80211w == NO_IEEE80211W || 1340 !(ie.capabilities & WPA_CAPABILITY_MGMT_FRAME_PROTECTION)) 1341 sel = 0; 1342 if (sel & WPA_CIPHER_AES_128_CMAC) { 1343 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC; 1344 wpa_msg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher " 1345 "AES-128-CMAC"); 1346 } else { 1347 wpa_s->mgmt_group_cipher = 0; 1348 wpa_msg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher"); 1349 } 1350 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP, 1351 wpa_s->mgmt_group_cipher); 1352#endif /* CONFIG_IEEE80211W */ 1353 1354 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) { 1355 wpa_printf(MSG_WARNING, "WPA: Failed to generate WPA IE."); 1356 return -1; 1357 } 1358 1359 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) 1360 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN); 1361 else 1362 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa); 1363 1364 return 0; 1365} 1366 1367 1368/** 1369 * wpa_supplicant_associate - Request association 1370 * @wpa_s: Pointer to wpa_supplicant data 1371 * @bss: Scan results for the selected BSS, or %NULL if not available 1372 * @ssid: Configuration data for the selected network 1373 * 1374 * This function is used to request %wpa_supplicant to associate with a BSS. 1375 */ 1376void wpa_supplicant_associate(struct wpa_supplicant *wpa_s, 1377 struct wpa_scan_result *bss, 1378 struct wpa_ssid *ssid) 1379{ 1380 u8 wpa_ie[80]; 1381 size_t wpa_ie_len; 1382 int use_crypt, ret, i; 1383 int algs = AUTH_ALG_OPEN_SYSTEM; 1384 wpa_cipher cipher_pairwise, cipher_group; 1385 struct wpa_driver_associate_params params; 1386 int wep_keys_set = 0; 1387 struct wpa_driver_capa capa; 1388 int assoc_failed = 0; 1389 1390 wpa_s->reassociate = 0; 1391 if (bss) { 1392 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR 1393 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid), 1394 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq); 1395 os_memset(wpa_s->bssid, 0, ETH_ALEN); 1396 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN); 1397 wpa_s->link_speed = bss->maxrate; 1398 wpa_s->rssi = bss->level; 1399 } else { 1400 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'", 1401 wpa_ssid_txt(ssid->ssid, ssid->ssid_len)); 1402 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); 1403 } 1404 wpa_supplicant_cancel_scan(wpa_s); 1405 1406 /* Starting new association, so clear the possibly used WPA IE from the 1407 * previous association. */ 1408 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); 1409 1410#ifdef IEEE8021X_EAPOL 1411 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 1412 if (ssid->leap) { 1413 if (ssid->non_leap == 0) 1414 algs = AUTH_ALG_LEAP; 1415 else 1416 algs |= AUTH_ALG_LEAP; 1417 } 1418 } 1419#endif /* IEEE8021X_EAPOL */ 1420 wpa_printf(MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs); 1421 if (ssid->auth_alg) { 1422 algs = 0; 1423 if (ssid->auth_alg & WPA_AUTH_ALG_OPEN) 1424 algs |= AUTH_ALG_OPEN_SYSTEM; 1425 if (ssid->auth_alg & WPA_AUTH_ALG_SHARED) 1426 algs |= AUTH_ALG_SHARED_KEY; 1427 if (ssid->auth_alg & WPA_AUTH_ALG_LEAP) 1428 algs |= AUTH_ALG_LEAP; 1429 wpa_printf(MSG_DEBUG, "Overriding auth_alg selection: 0x%x", 1430 algs); 1431 } 1432 wpa_drv_set_auth_alg(wpa_s, algs); 1433 1434 if (bss && (bss->wpa_ie_len || bss->rsn_ie_len) && 1435 (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK))) { 1436 int try_opportunistic; 1437 try_opportunistic = ssid->proactive_key_caching && 1438 (ssid->proto & WPA_PROTO_RSN); 1439 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid, 1440 wpa_s->current_ssid, 1441 try_opportunistic) == 0) 1442 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1); 1443 wpa_ie_len = sizeof(wpa_ie); 1444 if (wpa_supplicant_set_suites(wpa_s, bss, ssid, 1445 wpa_ie, &wpa_ie_len)) { 1446 wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key " 1447 "management and encryption suites"); 1448 return; 1449 } 1450 } else if (ssid->key_mgmt & 1451 (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_IEEE8021X | 1452 WPA_KEY_MGMT_WPA_NONE)) { 1453 wpa_ie_len = sizeof(wpa_ie); 1454 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid, 1455 wpa_ie, &wpa_ie_len)) { 1456 wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key " 1457 "management and encryption suites (no scan " 1458 "results)"); 1459 return; 1460 } 1461 } else { 1462 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 1463 wpa_ie_len = 0; 1464 } 1465 1466 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL); 1467 use_crypt = 1; 1468 cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher); 1469 cipher_group = cipher_suite2driver(wpa_s->group_cipher); 1470 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 1471 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 1472 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) 1473 use_crypt = 0; 1474 for (i = 0; i < NUM_WEP_KEYS; i++) { 1475 if (ssid->wep_key_len[i]) { 1476 use_crypt = 1; 1477 wep_keys_set = 1; 1478 wpa_set_wep_key(wpa_s, 1479 i == ssid->wep_tx_keyidx, 1480 i, ssid->wep_key[i], 1481 ssid->wep_key_len[i]); 1482 } 1483 } 1484 } 1485 1486#ifdef IEEE8021X_EAPOL 1487 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 1488 if ((ssid->eapol_flags & 1489 (EAPOL_FLAG_REQUIRE_KEY_UNICAST | 1490 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 && 1491 !wep_keys_set) { 1492 use_crypt = 0; 1493 } else { 1494 /* Assume that dynamic WEP-104 keys will be used and 1495 * set cipher suites in order for drivers to expect 1496 * encryption. */ 1497 cipher_pairwise = cipher_group = CIPHER_WEP104; 1498 } 1499 } 1500#endif /* IEEE8021X_EAPOL */ 1501 1502 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 1503 /* Set the key before (and later after) association */ 1504 wpa_supplicant_set_wpa_none_key(wpa_s, ssid); 1505 } 1506 1507 wpa_drv_set_drop_unencrypted(wpa_s, use_crypt); 1508 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING); 1509 os_memset(¶ms, 0, sizeof(params)); 1510 if (bss) { 1511 params.bssid = bss->bssid; 1512 params.ssid = bss->ssid; 1513 params.ssid_len = bss->ssid_len; 1514 params.freq = bss->freq; 1515 } else { 1516 params.ssid = ssid->ssid; 1517 params.ssid_len = ssid->ssid_len; 1518 } 1519 if (ssid->mode == 1 && ssid->frequency > 0 && params.freq == 0) 1520 params.freq = ssid->frequency; /* Initial channel for IBSS */ 1521 params.wpa_ie = wpa_ie; 1522 params.wpa_ie_len = wpa_ie_len; 1523 params.pairwise_suite = cipher_pairwise; 1524 params.group_suite = cipher_group; 1525 params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt); 1526 params.auth_alg = algs; 1527 params.mode = ssid->mode; 1528 for (i = 0; i < NUM_WEP_KEYS; i++) { 1529 if (ssid->wep_key_len[i]) 1530 params.wep_key[i] = ssid->wep_key[i]; 1531 params.wep_key_len[i] = ssid->wep_key_len[i]; 1532 } 1533 params.wep_tx_keyidx = ssid->wep_tx_keyidx; 1534 1535#ifdef CONFIG_IEEE80211W 1536 switch (ssid->ieee80211w) { 1537 case NO_IEEE80211W: 1538 params.mgmt_frame_protection = NO_MGMT_FRAME_PROTECTION; 1539 break; 1540 case IEEE80211W_OPTIONAL: 1541 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_OPTIONAL; 1542 break; 1543 case IEEE80211W_REQUIRED: 1544 params.mgmt_frame_protection = MGMT_FRAME_PROTECTION_REQUIRED; 1545 break; 1546 } 1547#endif /* CONFIG_IEEE80211W */ 1548 1549 if (wpa_s->use_client_mlme) 1550 ret = ieee80211_sta_associate(wpa_s, ¶ms); 1551 else 1552 ret = wpa_drv_associate(wpa_s, ¶ms); 1553 if (ret < 0) { 1554 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver " 1555 "failed"); 1556 /* try to continue anyway; new association will be tried again 1557 * after timeout */ 1558 assoc_failed = 1; 1559 } 1560 1561 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 1562 /* Set the key after the association just in case association 1563 * cleared the previously configured key. */ 1564 wpa_supplicant_set_wpa_none_key(wpa_s, ssid); 1565 /* No need to timeout authentication since there is no key 1566 * management. */ 1567 wpa_supplicant_cancel_auth_timeout(wpa_s); 1568 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED); 1569 } else { 1570 /* Timeout for IEEE 802.11 authentication and association */ 1571 int timeout = 60; 1572 1573 if (assoc_failed) { 1574 /* give IBSS a bit more time */ 1575 timeout = ssid->mode ? 10 : 5; 1576 } else if (wpa_s->conf->ap_scan == 1) { 1577 /* give IBSS a bit more time */ 1578 timeout = ssid->mode ? 20 : 10; 1579 } 1580 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0); 1581 } 1582 1583 if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 && 1584 capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) { 1585 /* Set static WEP keys again */ 1586 int j; 1587 for (j = 0; j < NUM_WEP_KEYS; j++) { 1588 if (ssid->wep_key_len[j]) { 1589 wpa_set_wep_key(wpa_s, 1590 j == ssid->wep_tx_keyidx, 1591 j, ssid->wep_key[j], 1592 ssid->wep_key_len[j]); 1593 } 1594 } 1595 } 1596 1597 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) { 1598 /* 1599 * Do not allow EAP session resumption between different 1600 * network configurations. 1601 */ 1602 eapol_sm_invalidate_cached_session(wpa_s->eapol); 1603 } 1604 wpa_s->current_ssid = ssid; 1605 wpa_sm_set_config(wpa_s->wpa, wpa_s->current_ssid); 1606 wpa_supplicant_initiate_eapol(wpa_s); 1607} 1608 1609 1610/** 1611 * wpa_supplicant_disassociate - Disassociate the current connection 1612 * @wpa_s: Pointer to wpa_supplicant data 1613 * @reason_code: IEEE 802.11 reason code for the disassociate frame 1614 * 1615 * This function is used to request %wpa_supplicant to disassociate with the 1616 * current AP. 1617 */ 1618void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s, 1619 int reason_code) 1620{ 1621 u8 *addr = NULL; 1622 if (os_memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 0) 1623 { 1624 if (wpa_s->use_client_mlme) 1625 ieee80211_sta_disassociate(wpa_s, reason_code); 1626 else 1627 wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code); 1628 addr = wpa_s->bssid; 1629 } 1630 wpa_clear_keys(wpa_s, addr); 1631 wpa_supplicant_mark_disassoc(wpa_s); 1632 wpa_s->current_ssid = NULL; 1633 wpa_sm_set_config(wpa_s->wpa, NULL); 1634 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 1635} 1636 1637 1638/** 1639 * wpa_supplicant_deauthenticate - Deauthenticate the current connection 1640 * @wpa_s: Pointer to wpa_supplicant data 1641 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame 1642 * 1643 * This function is used to request %wpa_supplicant to disassociate with the 1644 * current AP. 1645 */ 1646void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s, 1647 int reason_code) 1648{ 1649 u8 *addr = NULL; 1650 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 1651 if (os_memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 0) 1652 { 1653 if (wpa_s->use_client_mlme) 1654 ieee80211_sta_deauthenticate(wpa_s, reason_code); 1655 else 1656 wpa_drv_deauthenticate(wpa_s, wpa_s->bssid, 1657 reason_code); 1658 addr = wpa_s->bssid; 1659 } 1660 wpa_clear_keys(wpa_s, addr); 1661 wpa_s->current_ssid = NULL; 1662 wpa_sm_set_config(wpa_s->wpa, NULL); 1663 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 1664 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE); 1665 eapol_sm_notify_portValid(wpa_s->eapol, FALSE); 1666} 1667 1668 1669/** 1670 * wpa_supplicant_get_scan_results - Get scan results 1671 * @wpa_s: Pointer to wpa_supplicant data 1672 * Returns: 0 on success, -1 on failure 1673 * 1674 * This function is request the current scan results from the driver and stores 1675 * a local copy of the results in wpa_s->scan_results. 1676 */ 1677int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s) 1678{ 1679#define SCAN_AP_LIMIT 128 1680 struct wpa_scan_result *results, *tmp; 1681 int num; 1682 1683 results = os_malloc(SCAN_AP_LIMIT * sizeof(struct wpa_scan_result)); 1684 if (results == NULL) { 1685 wpa_printf(MSG_WARNING, "Failed to allocate memory for scan " 1686 "results"); 1687 return -1; 1688 } 1689 1690 if (wpa_s->use_client_mlme) { 1691 num = ieee80211_sta_get_scan_results(wpa_s, results, 1692 SCAN_AP_LIMIT); 1693 } else 1694 num = wpa_drv_get_scan_results(wpa_s, results, SCAN_AP_LIMIT); 1695 wpa_printf(MSG_DEBUG, "Scan results: %d", num); 1696 if (num < 0) { 1697 wpa_printf(MSG_DEBUG, "Failed to get scan results"); 1698 os_free(results); 1699 return -1; 1700 } 1701 if (num > SCAN_AP_LIMIT) { 1702 wpa_printf(MSG_INFO, "Not enough room for all APs (%d < %d)", 1703 num, SCAN_AP_LIMIT); 1704 num = SCAN_AP_LIMIT; 1705 } 1706 1707 /* Free unneeded memory for unused scan result entries */ 1708 tmp = os_realloc(results, num * sizeof(struct wpa_scan_result)); 1709 if (tmp || num == 0) { 1710 results = tmp; 1711 } 1712 1713 os_free(wpa_s->scan_results); 1714 wpa_s->scan_results = results; 1715 wpa_s->num_scan_results = num; 1716 1717 return 0; 1718} 1719 1720 1721#ifndef CONFIG_NO_WPA 1722static int wpa_get_beacon_ie(struct wpa_supplicant *wpa_s) 1723{ 1724 int i, ret = 0; 1725 struct wpa_scan_result *results, *curr = NULL; 1726 1727 results = wpa_s->scan_results; 1728 if (results == NULL) { 1729 return -1; 1730 } 1731 1732 for (i = 0; i < wpa_s->num_scan_results; i++) { 1733 struct wpa_ssid *ssid = wpa_s->current_ssid; 1734 if (os_memcmp(results[i].bssid, wpa_s->bssid, ETH_ALEN) != 0) 1735 continue; 1736 if (ssid == NULL || 1737 ((results[i].ssid_len == ssid->ssid_len && 1738 os_memcmp(results[i].ssid, ssid->ssid, ssid->ssid_len) 1739 == 0) || 1740 ssid->ssid_len == 0)) { 1741 curr = &results[i]; 1742 break; 1743 } 1744 } 1745 1746 if (curr) { 1747 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, curr->wpa_ie, 1748 curr->wpa_ie_len) || 1749 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, curr->rsn_ie, 1750 curr->rsn_ie_len)) 1751 ret = -1; 1752 } else { 1753 ret = -1; 1754 } 1755 1756 return ret; 1757} 1758 1759 1760static int wpa_supplicant_get_beacon_ie(void *ctx) 1761{ 1762 struct wpa_supplicant *wpa_s = ctx; 1763 if (wpa_get_beacon_ie(wpa_s) == 0) { 1764 return 0; 1765 } 1766 1767 /* No WPA/RSN IE found in the cached scan results. Try to get updated 1768 * scan results from the driver. */ 1769 if (wpa_supplicant_get_scan_results(wpa_s) < 0) { 1770 return -1; 1771 } 1772 1773 return wpa_get_beacon_ie(wpa_s); 1774} 1775#endif /* CONFIG_NO_WPA */ 1776 1777 1778/** 1779 * wpa_supplicant_get_ssid - Get a pointer to the current network structure 1780 * @wpa_s: Pointer to wpa_supplicant data 1781 * Returns: A pointer to the current network structure or %NULL on failure 1782 */ 1783struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s) 1784{ 1785 struct wpa_ssid *entry; 1786 u8 ssid[MAX_SSID_LEN]; 1787 int res; 1788 size_t ssid_len; 1789 u8 bssid[ETH_ALEN]; 1790 int wired; 1791 1792 if (wpa_s->use_client_mlme) { 1793 if (ieee80211_sta_get_ssid(wpa_s, ssid, &ssid_len)) { 1794 wpa_printf(MSG_WARNING, "Could not read SSID from " 1795 "MLME."); 1796 return NULL; 1797 } 1798 } else { 1799 res = wpa_drv_get_ssid(wpa_s, ssid); 1800 if (res < 0) { 1801 wpa_printf(MSG_WARNING, "Could not read SSID from " 1802 "driver."); 1803 return NULL; 1804 } 1805 ssid_len = res; 1806 } 1807 1808 if (wpa_s->use_client_mlme) 1809 os_memcpy(bssid, wpa_s->bssid, ETH_ALEN); 1810 else if (wpa_drv_get_bssid(wpa_s, bssid) < 0) { 1811 wpa_printf(MSG_WARNING, "Could not read BSSID from driver."); 1812 return NULL; 1813 } 1814 1815 wired = wpa_s->conf->ap_scan == 0 && wpa_s->driver && 1816 os_strcmp(wpa_s->driver->name, "wired") == 0; 1817 1818 entry = wpa_s->conf->ssid; 1819 while (entry) { 1820 if (!entry->disabled && 1821 ((ssid_len == entry->ssid_len && 1822 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) && 1823 (!entry->bssid_set || 1824 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)) 1825 return entry; 1826 entry = entry->next; 1827 } 1828 1829 return NULL; 1830} 1831 1832 1833#ifndef CONFIG_NO_WPA 1834static u8 * _wpa_alloc_eapol(void *wpa_s, u8 type, 1835 const void *data, u16 data_len, 1836 size_t *msg_len, void **data_pos) 1837{ 1838 return wpa_alloc_eapol(wpa_s, type, data, data_len, msg_len, data_pos); 1839} 1840 1841 1842static int _wpa_ether_send(void *wpa_s, const u8 *dest, u16 proto, 1843 const u8 *buf, size_t len) 1844{ 1845 return wpa_ether_send(wpa_s, dest, proto, buf, len); 1846} 1847 1848 1849static void _wpa_supplicant_cancel_auth_timeout(void *wpa_s) 1850{ 1851 wpa_supplicant_cancel_auth_timeout(wpa_s); 1852} 1853 1854 1855static void _wpa_supplicant_set_state(void *wpa_s, wpa_states state) 1856{ 1857 wpa_supplicant_set_state(wpa_s, state); 1858} 1859 1860 1861static wpa_states _wpa_supplicant_get_state(void *wpa_s) 1862{ 1863 return wpa_supplicant_get_state(wpa_s); 1864} 1865 1866 1867static void _wpa_supplicant_disassociate(void *wpa_s, int reason_code) 1868{ 1869 wpa_supplicant_disassociate(wpa_s, reason_code); 1870 /* Schedule a scan to make sure we continue looking for networks */ 1871 wpa_supplicant_req_scan(wpa_s, 0, 0); 1872} 1873 1874 1875static void _wpa_supplicant_deauthenticate(void *wpa_s, int reason_code) 1876{ 1877 wpa_supplicant_deauthenticate(wpa_s, reason_code); 1878 /* Schedule a scan to make sure we continue looking for networks */ 1879 wpa_supplicant_req_scan(wpa_s, 0, 0); 1880} 1881 1882 1883static struct wpa_ssid * _wpa_supplicant_get_ssid(void *wpa_s) 1884{ 1885 return wpa_supplicant_get_ssid(wpa_s); 1886} 1887 1888 1889static int wpa_supplicant_get_bssid(void *ctx, u8 *bssid) 1890{ 1891 struct wpa_supplicant *wpa_s = ctx; 1892 if (wpa_s->use_client_mlme) { 1893 os_memcpy(bssid, wpa_s->bssid, ETH_ALEN); 1894 return 0; 1895 } 1896 return wpa_drv_get_bssid(wpa_s, bssid); 1897} 1898 1899 1900static int wpa_supplicant_set_key(void *wpa_s, wpa_alg alg, 1901 const u8 *addr, int key_idx, int set_tx, 1902 const u8 *seq, size_t seq_len, 1903 const u8 *key, size_t key_len) 1904{ 1905 return wpa_drv_set_key(wpa_s, alg, addr, key_idx, set_tx, seq, seq_len, 1906 key, key_len); 1907} 1908 1909 1910static int wpa_supplicant_mlme_setprotection(void *wpa_s, const u8 *addr, 1911 int protection_type, 1912 int key_type) 1913{ 1914 return wpa_drv_mlme_setprotection(wpa_s, addr, protection_type, 1915 key_type); 1916} 1917 1918 1919static int wpa_supplicant_add_pmkid(void *wpa_s, 1920 const u8 *bssid, const u8 *pmkid) 1921{ 1922 return wpa_drv_add_pmkid(wpa_s, bssid, pmkid); 1923} 1924 1925 1926static int wpa_supplicant_remove_pmkid(void *wpa_s, 1927 const u8 *bssid, const u8 *pmkid) 1928{ 1929 return wpa_drv_remove_pmkid(wpa_s, bssid, pmkid); 1930} 1931#endif /* CONFIG_NO_WPA */ 1932 1933 1934static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s, 1935 const char *name) 1936{ 1937 int i; 1938 1939 if (wpa_s == NULL) 1940 return -1; 1941 1942 if (wpa_supplicant_drivers[0] == NULL) { 1943 wpa_printf(MSG_ERROR, "No driver interfaces build into " 1944 "wpa_supplicant."); 1945 return -1; 1946 } 1947 1948 if (name == NULL) { 1949 /* default to first driver in the list */ 1950 wpa_s->driver = wpa_supplicant_drivers[0]; 1951 return 0; 1952 } 1953 1954 for (i = 0; wpa_supplicant_drivers[i]; i++) { 1955 if (os_strcmp(name, wpa_supplicant_drivers[i]->name) == 0) { 1956 wpa_s->driver = wpa_supplicant_drivers[i]; 1957 return 0; 1958 } 1959 } 1960 1961 wpa_printf(MSG_ERROR, "Unsupported driver '%s'.\n", name); 1962 return -1; 1963} 1964 1965 1966void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr, 1967 const u8 *buf, size_t len) 1968{ 1969 struct wpa_supplicant *wpa_s = ctx; 1970 1971 wpa_printf(MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr)); 1972 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len); 1973 1974 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) { 1975 wpa_printf(MSG_DEBUG, "Ignored received EAPOL frame since " 1976 "no key management is configured"); 1977 return; 1978 } 1979 1980 if (wpa_s->eapol_received == 0) { 1981 /* Timeout for completing IEEE 802.1X and WPA authentication */ 1982 wpa_supplicant_req_auth_timeout( 1983 wpa_s, 1984 (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X || 1985 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) ? 1986 70 : 10, 0); 1987 } 1988 wpa_s->eapol_received++; 1989 1990 if (wpa_s->countermeasures) { 1991 wpa_printf(MSG_INFO, "WPA: Countermeasures - dropped EAPOL " 1992 "packet"); 1993 return; 1994 } 1995 1996 /* Source address of the incoming EAPOL frame could be compared to the 1997 * current BSSID. However, it is possible that a centralized 1998 * Authenticator could be using another MAC address than the BSSID of 1999 * an AP, so just allow any address to be used for now. The replies are 2000 * still sent to the current BSSID (if available), though. */ 2001 2002 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN); 2003 if (wpa_s->key_mgmt != WPA_KEY_MGMT_PSK && 2004 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0) 2005 return; 2006 wpa_drv_poll(wpa_s); 2007 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len); 2008} 2009 2010 2011/** 2012 * wpa_supplicant_driver_init - Initialize driver interface parameters 2013 * @wpa_s: Pointer to wpa_supplicant data 2014 * @wait_for_interface: 0 = do not wait for the interface (reports a failure if 2015 * the interface is not present), 1 = wait until the interface is available 2016 * Returns: 0 on success, -1 on failure 2017 * 2018 * This function is called to initialize driver interface parameters. 2019 * wpa_drv_init() must have been called before this function to initialize the 2020 * driver interface. 2021 */ 2022int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s, 2023 int wait_for_interface) 2024{ 2025 static int interface_count = 0; 2026 2027 for (;;) { 2028 if (wpa_s->driver->send_eapol) { 2029 const u8 *addr = wpa_drv_get_mac_addr(wpa_s); 2030 if (addr) 2031 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN); 2032 break; 2033 } 2034 wpa_s->l2 = l2_packet_init(wpa_s->ifname, 2035 wpa_drv_get_mac_addr(wpa_s), 2036 ETH_P_EAPOL, 2037 wpa_supplicant_rx_eapol, wpa_s, 0); 2038 if (wpa_s->l2) 2039 break; 2040 else if (!wait_for_interface) 2041 return -1; 2042 wpa_printf(MSG_DEBUG, "Waiting for interface.."); 2043 os_sleep(5, 0); 2044 } 2045 2046 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) { 2047 wpa_printf(MSG_ERROR, "Failed to get own L2 address"); 2048 return -1; 2049 } 2050 2051 wpa_printf(MSG_DEBUG, "Own MAC address: " MACSTR, 2052 MAC2STR(wpa_s->own_addr)); 2053 2054 if (wpa_s->bridge_ifname[0]) { 2055 wpa_printf(MSG_DEBUG, "Receiving packets from bridge interface" 2056 " '%s'", wpa_s->bridge_ifname); 2057 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname, 2058 wpa_s->own_addr, 2059 ETH_P_EAPOL, 2060 wpa_supplicant_rx_eapol, wpa_s, 2061 0); 2062 if (wpa_s->l2_br == NULL) { 2063 wpa_printf(MSG_ERROR, "Failed to open l2_packet " 2064 "connection for the bridge interface '%s'", 2065 wpa_s->bridge_ifname); 2066 return -1; 2067 } 2068 } 2069 2070 /* Backwards compatibility call to set_wpa() handler. This is called 2071 * only just after init and just before deinit, so these handler can be 2072 * used to implement same functionality. */ 2073 if (wpa_drv_set_wpa(wpa_s, 1) < 0) { 2074 struct wpa_driver_capa capa; 2075 if (wpa_drv_get_capa(wpa_s, &capa) < 0 || 2076 !(capa.flags & (WPA_DRIVER_CAPA_KEY_MGMT_WPA | 2077 WPA_DRIVER_CAPA_KEY_MGMT_WPA2))) { 2078 wpa_printf(MSG_DEBUG, "Driver does not support WPA."); 2079 /* Continue to allow non-WPA modes to be used. */ 2080 } else { 2081 wpa_printf(MSG_ERROR, "Failed to enable WPA in the " 2082 "driver."); 2083 return -1; 2084 } 2085 } 2086 2087 wpa_clear_keys(wpa_s, NULL); 2088 2089 /* Make sure that TKIP countermeasures are not left enabled (could 2090 * happen if wpa_supplicant is killed during countermeasures. */ 2091 wpa_drv_set_countermeasures(wpa_s, 0); 2092 2093 wpa_drv_set_drop_unencrypted(wpa_s, 1); 2094 2095 wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN; 2096 wpa_supplicant_req_scan(wpa_s, interface_count, 100000); 2097 interface_count++; 2098 2099 return 0; 2100} 2101 2102 2103static int wpa_supplicant_daemon(const char *pid_file) 2104{ 2105 wpa_printf(MSG_DEBUG, "Daemonize.."); 2106 return os_daemonize(pid_file); 2107} 2108 2109 2110static struct wpa_supplicant * wpa_supplicant_alloc(void) 2111{ 2112 struct wpa_supplicant *wpa_s; 2113 2114 wpa_s = os_zalloc(sizeof(*wpa_s)); 2115 if (wpa_s == NULL) 2116 return NULL; 2117 wpa_s->scan_req = 1; 2118 2119 return wpa_s; 2120} 2121 2122 2123static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s, 2124 struct wpa_interface *iface) 2125{ 2126 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver " 2127 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname, 2128 iface->confname ? iface->confname : "N/A", 2129 iface->driver ? iface->driver : "default", 2130 iface->ctrl_interface ? iface->ctrl_interface : "N/A", 2131 iface->bridge_ifname ? iface->bridge_ifname : "N/A"); 2132 2133 if (wpa_supplicant_set_driver(wpa_s, iface->driver) < 0) { 2134 return -1; 2135 } 2136 2137 if (iface->confname) { 2138#ifdef CONFIG_BACKEND_FILE 2139 wpa_s->confname = os_rel2abs_path(iface->confname); 2140 if (wpa_s->confname == NULL) { 2141 wpa_printf(MSG_ERROR, "Failed to get absolute path " 2142 "for configuration file '%s'.", 2143 iface->confname); 2144 return -1; 2145 } 2146 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'", 2147 iface->confname, wpa_s->confname); 2148#else /* CONFIG_BACKEND_FILE */ 2149 wpa_s->confname = os_strdup(iface->confname); 2150#endif /* CONFIG_BACKEND_FILE */ 2151 wpa_s->conf = wpa_config_read(wpa_s->confname); 2152 if (wpa_s->conf == NULL) { 2153 wpa_printf(MSG_ERROR, "Failed to read or parse " 2154 "configuration '%s'.", wpa_s->confname); 2155 return -1; 2156 } 2157 2158 /* 2159 * Override ctrl_interface and driver_param if set on command 2160 * line. 2161 */ 2162 if (iface->ctrl_interface) { 2163 os_free(wpa_s->conf->ctrl_interface); 2164 wpa_s->conf->ctrl_interface = 2165 os_strdup(iface->ctrl_interface); 2166 } 2167 2168 if (iface->driver_param) { 2169 os_free(wpa_s->conf->driver_param); 2170 wpa_s->conf->driver_param = 2171 os_strdup(iface->driver_param); 2172 } 2173 } else 2174 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface, 2175 iface->driver_param); 2176 2177 if (wpa_s->conf == NULL) { 2178 wpa_printf(MSG_ERROR, "\nNo configuration found."); 2179 return -1; 2180 } 2181 2182 if (iface->ifname == NULL) { 2183 wpa_printf(MSG_ERROR, "\nInterface name is required."); 2184 return -1; 2185 } 2186 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) { 2187 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.", 2188 iface->ifname); 2189 return -1; 2190 } 2191 os_strncpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname)); 2192 2193 if (iface->bridge_ifname) { 2194 if (os_strlen(iface->bridge_ifname) >= 2195 sizeof(wpa_s->bridge_ifname)) { 2196 wpa_printf(MSG_ERROR, "\nToo long bridge interface " 2197 "name '%s'.", iface->bridge_ifname); 2198 return -1; 2199 } 2200 os_strncpy(wpa_s->bridge_ifname, iface->bridge_ifname, 2201 sizeof(wpa_s->bridge_ifname)); 2202 } 2203 2204 return 0; 2205} 2206 2207 2208static int wpa_supplicant_init_eapol(struct wpa_supplicant *wpa_s) 2209{ 2210#ifdef IEEE8021X_EAPOL 2211 struct eapol_ctx *ctx; 2212 ctx = os_zalloc(sizeof(*ctx)); 2213 if (ctx == NULL) { 2214 wpa_printf(MSG_ERROR, "Failed to allocate EAPOL context."); 2215 return -1; 2216 } 2217 2218 ctx->ctx = wpa_s; 2219 ctx->msg_ctx = wpa_s; 2220 ctx->eapol_send_ctx = wpa_s; 2221 ctx->preauth = 0; 2222 ctx->eapol_done_cb = wpa_supplicant_notify_eapol_done; 2223 ctx->eapol_send = wpa_supplicant_eapol_send; 2224 ctx->set_wep_key = wpa_eapol_set_wep_key; 2225 ctx->set_config_blob = wpa_supplicant_set_config_blob; 2226 ctx->get_config_blob = wpa_supplicant_get_config_blob; 2227 ctx->aborted_cached = wpa_supplicant_aborted_cached; 2228 ctx->opensc_engine_path = wpa_s->conf->opensc_engine_path; 2229 ctx->pkcs11_engine_path = wpa_s->conf->pkcs11_engine_path; 2230 ctx->pkcs11_module_path = wpa_s->conf->pkcs11_module_path; 2231 wpa_s->eapol = eapol_sm_init(ctx); 2232 if (wpa_s->eapol == NULL) { 2233 os_free(ctx); 2234 wpa_printf(MSG_ERROR, "Failed to initialize EAPOL state " 2235 "machines."); 2236 return -1; 2237 } 2238#endif /* IEEE8021X_EAPOL */ 2239 2240 return 0; 2241} 2242 2243 2244static int wpa_supplicant_init_wpa(struct wpa_supplicant *wpa_s) 2245{ 2246#ifndef CONFIG_NO_WPA 2247 struct wpa_sm_ctx *ctx; 2248 ctx = os_zalloc(sizeof(*ctx)); 2249 if (ctx == NULL) { 2250 wpa_printf(MSG_ERROR, "Failed to allocate WPA context."); 2251 return -1; 2252 } 2253 2254 ctx->ctx = wpa_s; 2255 ctx->set_state = _wpa_supplicant_set_state; 2256 ctx->get_state = _wpa_supplicant_get_state; 2257 ctx->deauthenticate = _wpa_supplicant_deauthenticate; 2258 ctx->disassociate = _wpa_supplicant_disassociate; 2259 ctx->set_key = wpa_supplicant_set_key; 2260 ctx->scan = wpa_supplicant_scan; 2261 ctx->get_ssid = _wpa_supplicant_get_ssid; 2262 ctx->get_bssid = wpa_supplicant_get_bssid; 2263 ctx->ether_send = _wpa_ether_send; 2264 ctx->get_beacon_ie = wpa_supplicant_get_beacon_ie; 2265 ctx->alloc_eapol = _wpa_alloc_eapol; 2266 ctx->cancel_auth_timeout = _wpa_supplicant_cancel_auth_timeout; 2267 ctx->add_pmkid = wpa_supplicant_add_pmkid; 2268 ctx->remove_pmkid = wpa_supplicant_remove_pmkid; 2269 ctx->set_config_blob = wpa_supplicant_set_config_blob; 2270 ctx->get_config_blob = wpa_supplicant_get_config_blob; 2271 ctx->mlme_setprotection = wpa_supplicant_mlme_setprotection; 2272 2273 wpa_s->wpa = wpa_sm_init(ctx); 2274 if (wpa_s->wpa == NULL) { 2275 wpa_printf(MSG_ERROR, "Failed to initialize WPA state " 2276 "machine"); 2277 return -1; 2278 } 2279#endif /* CONFIG_NO_WPA */ 2280 2281 return 0; 2282} 2283 2284 2285static int wpa_supplicant_init_iface2(struct wpa_supplicant *wpa_s, 2286 int wait_for_interface) 2287{ 2288 const char *ifname; 2289 struct wpa_driver_capa capa; 2290 2291 wpa_printf(MSG_DEBUG, "Initializing interface (2) '%s'", 2292 wpa_s->ifname); 2293 2294 if (wpa_supplicant_init_eapol(wpa_s) < 0) 2295 return -1; 2296 2297 /* RSNA Supplicant Key Management - INITIALIZE */ 2298 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE); 2299 eapol_sm_notify_portValid(wpa_s->eapol, FALSE); 2300 2301 /* Initialize driver interface and register driver event handler before 2302 * L2 receive handler so that association events are processed before 2303 * EAPOL-Key packets if both become available for the same select() 2304 * call. */ 2305 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname); 2306 if (wpa_s->drv_priv == NULL) { 2307 wpa_printf(MSG_ERROR, "Failed to initialize driver interface"); 2308 return -1; 2309 } 2310 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) { 2311 wpa_printf(MSG_ERROR, "Driver interface rejected " 2312 "driver_param '%s'", wpa_s->conf->driver_param); 2313 return -1; 2314 } 2315 2316 ifname = wpa_drv_get_ifname(wpa_s); 2317 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) { 2318 wpa_printf(MSG_DEBUG, "Driver interface replaced interface " 2319 "name with '%s'", ifname); 2320 os_strncpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname)); 2321 } 2322 2323 if (wpa_supplicant_init_wpa(wpa_s) < 0) 2324 return -1; 2325 2326 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname, 2327 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname : 2328 NULL); 2329 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth); 2330 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol); 2331 2332 if (wpa_s->conf->dot11RSNAConfigPMKLifetime && 2333 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME, 2334 wpa_s->conf->dot11RSNAConfigPMKLifetime)) { 2335 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for " 2336 "dot11RSNAConfigPMKLifetime"); 2337 return -1; 2338 } 2339 2340 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold && 2341 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD, 2342 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) { 2343 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for " 2344 "dot11RSNAConfigPMKReauthThreshold"); 2345 return -1; 2346 } 2347 2348 if (wpa_s->conf->dot11RSNAConfigSATimeout && 2349 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, 2350 wpa_s->conf->dot11RSNAConfigSATimeout)) { 2351 wpa_printf(MSG_ERROR, "Invalid WPA parameter value for " 2352 "dot11RSNAConfigSATimeout"); 2353 return -1; 2354 } 2355 2356 if (wpa_supplicant_driver_init(wpa_s, wait_for_interface) < 0) { 2357 return -1; 2358 } 2359 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr); 2360 2361 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s); 2362 if (wpa_s->ctrl_iface == NULL) { 2363 wpa_printf(MSG_ERROR, 2364 "Failed to initialize control interface '%s'.\n" 2365 "You may have another wpa_supplicant process " 2366 "already running or the file was\n" 2367 "left by an unclean termination of wpa_supplicant " 2368 "in which case you will need\n" 2369 "to manually remove this file before starting " 2370 "wpa_supplicant again.\n", 2371 wpa_s->conf->ctrl_interface); 2372 return -1; 2373 } 2374 2375 if (wpa_drv_get_capa(wpa_s, &capa) == 0 && 2376 capa.flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) { 2377 wpa_s->use_client_mlme = 1; 2378 if (ieee80211_sta_init(wpa_s)) 2379 return -1; 2380 } 2381 2382 return 0; 2383} 2384 2385 2386static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s) 2387{ 2388 if (wpa_s->drv_priv) { 2389 wpa_supplicant_deauthenticate(wpa_s, REASON_DEAUTH_LEAVING); 2390 2391 /* Backwards compatibility call to set_wpa() handler. This is 2392 * called only just after init and just before deinit, so these 2393 * handler can be used to implement same functionality. */ 2394 if (wpa_drv_set_wpa(wpa_s, 0) < 0) { 2395 wpa_printf(MSG_ERROR, "Failed to disable WPA in the " 2396 "driver."); 2397 } 2398 2399 wpa_drv_set_drop_unencrypted(wpa_s, 0); 2400 wpa_drv_set_countermeasures(wpa_s, 0); 2401 wpa_clear_keys(wpa_s, NULL); 2402 } 2403 2404 wpas_dbus_unregister_iface(wpa_s); 2405 2406 wpa_supplicant_cleanup(wpa_s); 2407 2408 if (wpa_s->drv_priv) 2409 wpa_drv_deinit(wpa_s); 2410} 2411 2412 2413/** 2414 * wpa_supplicant_add_iface - Add a new network interface 2415 * @global: Pointer to global data from wpa_supplicant_init() 2416 * @iface: Interface configuration options 2417 * Returns: Pointer to the created interface or %NULL on failure 2418 * 2419 * This function is used to add new network interfaces for %wpa_supplicant. 2420 * This can be called before wpa_supplicant_run() to add interfaces before the 2421 * main event loop has been started. In addition, new interfaces can be added 2422 * dynamically while %wpa_supplicant is already running. This could happen, 2423 * e.g., when a hotplug network adapter is inserted. 2424 */ 2425struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global, 2426 struct wpa_interface *iface) 2427{ 2428 struct wpa_supplicant *wpa_s; 2429 2430 if (global == NULL || iface == NULL) 2431 return NULL; 2432 2433 wpa_s = wpa_supplicant_alloc(); 2434 if (wpa_s == NULL) 2435 return NULL; 2436 2437 if (wpa_supplicant_init_iface(wpa_s, iface) || 2438 wpa_supplicant_init_iface2(wpa_s, 2439 global->params.wait_for_interface)) { 2440 wpa_printf(MSG_DEBUG, "Failed to add interface %s", 2441 iface->ifname); 2442 wpa_supplicant_deinit_iface(wpa_s); 2443 os_free(wpa_s); 2444 return NULL; 2445 } 2446 2447 wpa_s->global = global; 2448 2449 /* Register the interface with the dbus control interface */ 2450 if (wpas_dbus_register_iface(wpa_s)) { 2451 wpa_supplicant_deinit_iface(wpa_s); 2452 os_free(wpa_s); 2453 return NULL; 2454 } 2455 2456#ifdef ANDROID 2457 char scan_prop[PROPERTY_VALUE_MAX]; 2458 char *endp; 2459 if (property_get("wifi.supplicant_scan_interval", scan_prop, "5") != 0) { 2460 wpa_s->scan_interval = (int)strtol(scan_prop, &endp, 0); 2461 if (endp == scan_prop) { 2462 wpa_s->scan_interval = 5; 2463 } 2464 } 2465#endif 2466 wpa_s->next = global->ifaces; 2467 global->ifaces = wpa_s; 2468 2469 wpa_printf(MSG_DEBUG, "Added interface %s", wpa_s->ifname); 2470 2471 return wpa_s; 2472} 2473 2474 2475/** 2476 * wpa_supplicant_remove_iface - Remove a network interface 2477 * @global: Pointer to global data from wpa_supplicant_init() 2478 * @wpa_s: Pointer to the network interface to be removed 2479 * Returns: 0 if interface was removed, -1 if interface was not found 2480 * 2481 * This function can be used to dynamically remove network interfaces from 2482 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In 2483 * addition, this function is used to remove all remaining interfaces when 2484 * %wpa_supplicant is terminated. 2485 */ 2486int wpa_supplicant_remove_iface(struct wpa_global *global, 2487 struct wpa_supplicant *wpa_s) 2488{ 2489 struct wpa_supplicant *prev; 2490 2491 /* Remove interface from the global list of interfaces */ 2492 prev = global->ifaces; 2493 if (prev == wpa_s) { 2494 global->ifaces = wpa_s->next; 2495 } else { 2496 while (prev && prev->next != wpa_s) 2497 prev = prev->next; 2498 if (prev == NULL) 2499 return -1; 2500 prev->next = wpa_s->next; 2501 } 2502 2503 wpa_printf(MSG_DEBUG, "Removing interface %s", wpa_s->ifname); 2504 2505 wpa_supplicant_deinit_iface(wpa_s); 2506 os_free(wpa_s); 2507 2508 return 0; 2509} 2510 2511 2512/** 2513 * wpa_supplicant_get_iface - Get a new network interface 2514 * @global: Pointer to global data from wpa_supplicant_init() 2515 * @ifname: Interface name 2516 * Returns: Pointer to the interface or %NULL if not found 2517 */ 2518struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global, 2519 const char *ifname) 2520{ 2521 struct wpa_supplicant *wpa_s; 2522 2523 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 2524 if (os_strcmp(wpa_s->ifname, ifname) == 0) 2525 return wpa_s; 2526 } 2527 return NULL; 2528} 2529 2530 2531/** 2532 * wpa_supplicant_init - Initialize %wpa_supplicant 2533 * @params: Parameters for %wpa_supplicant 2534 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure 2535 * 2536 * This function is used to initialize %wpa_supplicant. After successful 2537 * initialization, the returned data pointer can be used to add and remove 2538 * network interfaces, and eventually, to deinitialize %wpa_supplicant. 2539 */ 2540struct wpa_global * wpa_supplicant_init(struct wpa_params *params) 2541{ 2542 struct wpa_global *global; 2543 int ret; 2544 2545 if (params == NULL) 2546 return NULL; 2547 2548 wpa_debug_open_file(params->wpa_debug_file_path); 2549 2550 ret = eap_peer_register_methods(); 2551 if (ret) { 2552 wpa_printf(MSG_ERROR, "Failed to register EAP methods"); 2553 if (ret == -2) 2554 wpa_printf(MSG_ERROR, "Two or more EAP methods used " 2555 "the same EAP type."); 2556 return NULL; 2557 } 2558 2559 global = os_zalloc(sizeof(*global)); 2560 if (global == NULL) 2561 return NULL; 2562 global->params.daemonize = params->daemonize; 2563 global->params.wait_for_interface = params->wait_for_interface; 2564 global->params.wait_for_monitor = params->wait_for_monitor; 2565 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface; 2566 if (params->pid_file) 2567 global->params.pid_file = os_strdup(params->pid_file); 2568 if (params->ctrl_interface) 2569 global->params.ctrl_interface = 2570 os_strdup(params->ctrl_interface); 2571 wpa_debug_level = global->params.wpa_debug_level = 2572 params->wpa_debug_level; 2573 wpa_debug_show_keys = global->params.wpa_debug_show_keys = 2574 params->wpa_debug_show_keys; 2575 wpa_debug_timestamp = global->params.wpa_debug_timestamp = 2576 params->wpa_debug_timestamp; 2577 2578 if (eloop_init(global)) { 2579 wpa_printf(MSG_ERROR, "Failed to initialize event loop"); 2580 wpa_supplicant_deinit(global); 2581 return NULL; 2582 } 2583 2584 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global); 2585 if (global->ctrl_iface == NULL) { 2586 wpa_supplicant_deinit(global); 2587 return NULL; 2588 } 2589 2590 if (global->params.dbus_ctrl_interface) { 2591 global->dbus_ctrl_iface = 2592 wpa_supplicant_dbus_ctrl_iface_init(global); 2593 if (global->dbus_ctrl_iface == NULL) { 2594 wpa_supplicant_deinit(global); 2595 return NULL; 2596 } 2597 } 2598 2599 if (global->params.wait_for_interface && global->params.daemonize && 2600 wpa_supplicant_daemon(global->params.pid_file)) { 2601 wpa_supplicant_deinit(global); 2602 return NULL; 2603 } 2604 2605 return global; 2606} 2607 2608 2609/** 2610 * wpa_supplicant_run - Run the %wpa_supplicant main event loop 2611 * @global: Pointer to global data from wpa_supplicant_init() 2612 * Returns: 0 after successful event loop run, -1 on failure 2613 * 2614 * This function starts the main event loop and continues running as long as 2615 * there are any remaining events. In most cases, this function is running as 2616 * long as the %wpa_supplicant process in still in use. 2617 */ 2618int wpa_supplicant_run(struct wpa_global *global) 2619{ 2620 struct wpa_supplicant *wpa_s; 2621 2622 if (!global->params.wait_for_interface && global->params.daemonize && 2623 wpa_supplicant_daemon(global->params.pid_file)) 2624 return -1; 2625 2626 if (global->params.wait_for_monitor) { 2627 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) 2628 if (wpa_s->ctrl_iface) 2629 wpa_supplicant_ctrl_iface_wait( 2630 wpa_s->ctrl_iface); 2631 } 2632 2633 eloop_register_signal_terminate(wpa_supplicant_terminate, NULL); 2634 eloop_register_signal_reconfig(wpa_supplicant_reconfig, NULL); 2635 2636 eloop_run(); 2637 2638 return 0; 2639} 2640 2641 2642/** 2643 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant 2644 * @global: Pointer to global data from wpa_supplicant_init() 2645 * 2646 * This function is called to deinitialize %wpa_supplicant and to free all 2647 * allocated resources. Remaining network interfaces will also be removed. 2648 */ 2649void wpa_supplicant_deinit(struct wpa_global *global) 2650{ 2651 if (global == NULL) 2652 return; 2653 2654 wpa_supplicant_terminate(0, global, NULL); 2655 2656 while (global->ifaces) 2657 wpa_supplicant_remove_iface(global, global->ifaces); 2658 2659 if (global->ctrl_iface) 2660 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface); 2661 if (global->dbus_ctrl_iface) 2662 wpa_supplicant_dbus_ctrl_iface_deinit(global->dbus_ctrl_iface); 2663 2664 eap_peer_unregister_methods(); 2665 2666 eloop_destroy(); 2667 2668 if (global->params.pid_file) { 2669 os_daemonize_terminate(global->params.pid_file); 2670 os_free(global->params.pid_file); 2671 } 2672 os_free(global->params.ctrl_interface); 2673 2674 os_free(global); 2675 wpa_debug_close_file(); 2676} 2677