Lines Matching refs:wpa_s
113 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
122 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
131 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
143 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
149 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
154 switch (wpa_s->group_cipher) {
173 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
174 "WPA-None", wpa_s->group_cipher);
181 return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
187 struct wpa_supplicant *wpa_s = eloop_ctx;
188 const u8 *bssid = wpa_s->bssid;
190 bssid = wpa_s->pending_bssid;
191 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
193 wpa_blacklist_add(wpa_s, bssid);
194 wpa_sm_notify_disassoc(wpa_s->wpa);
195 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
196 wpa_s->reassociate = 1;
202 wpa_supplicant_req_scan(wpa_s, 1, 0);
204 wpas_p2p_continue_after_scan(wpa_s);
210 * @wpa_s: Pointer to wpa_supplicant data
217 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
220 if (wpa_s->conf && wpa_s->conf->ap_scan == 0 &&
221 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
224 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
226 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
227 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
233 * @wpa_s: Pointer to wpa_supplicant data
239 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
241 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
242 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
243 wpa_blacklist_del(wpa_s, wpa_s->bssid);
249 * @wpa_s: Pointer to wpa_supplicant data
254 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
258 struct wpa_ssid *ssid = wpa_s->current_ssid;
262 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
263 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
268 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
269 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
270 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
275 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
276 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
278 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
279 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
280 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
282 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
285 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
296 if (wpa_s->conf && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
299 if (wpa_s->conf)
300 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
303 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
304 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
305 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
306 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
313 * @wpa_s: Pointer to wpa_supplicant data
320 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
326 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
328 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
330 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
331 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
332 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
333 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
334 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
335 wpa_s->group_cipher = WPA_CIPHER_NONE;
336 wpa_s->mgmt_group_cipher = 0;
340 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
341 wpa_s->group_cipher = WPA_CIPHER_WEP104;
344 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
345 wpa_s->group_cipher = WPA_CIPHER_WEP40;
350 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
351 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
352 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
353 wpa_s->pairwise_cipher);
354 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
356 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
357 wpa_s->mgmt_group_cipher);
360 pmksa_cache_clear_current(wpa_s->wpa);
364 void free_hw_features(struct wpa_supplicant *wpa_s)
367 if (wpa_s->hw.modes == NULL)
370 for (i = 0; i < wpa_s->hw.num_modes; i++) {
371 os_free(wpa_s->hw.modes[i].channels);
372 os_free(wpa_s->hw.modes[i].rates);
375 os_free(wpa_s->hw.modes);
376 wpa_s->hw.modes = NULL;
380 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
382 bgscan_deinit(wpa_s);
383 autoscan_deinit(wpa_s);
384 scard_deinit(wpa_s->scard);
385 wpa_s->scard = NULL;
386 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
387 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
388 l2_packet_deinit(wpa_s->l2);
389 wpa_s->l2 = NULL;
390 if (wpa_s->l2_br) {
391 l2_packet_deinit(wpa_s->l2_br);
392 wpa_s->l2_br = NULL;
395 if (wpa_s->conf != NULL) {
397 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
398 wpas_notify_network_removed(wpa_s, ssid);
401 os_free(wpa_s->confname);
402 wpa_s->confname = NULL;
404 os_free(wpa_s->confanother);
405 wpa_s->confanother = NULL;
407 wpa_sm_set_eapol(wpa_s->wpa, NULL);
408 eapol_sm_deinit(wpa_s->eapol);
409 wpa_s->eapol = NULL;
411 rsn_preauth_deinit(wpa_s->wpa);
414 wpa_tdls_deinit(wpa_s->wpa);
417 pmksa_candidate_free(wpa_s->wpa);
418 wpa_sm_deinit(wpa_s->wpa);
419 wpa_s->wpa = NULL;
420 wpa_blacklist_clear(wpa_s);
422 wpa_bss_deinit(wpa_s);
424 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
425 wpa_supplicant_cancel_scan(wpa_s);
426 wpa_supplicant_cancel_auth_timeout(wpa_s);
427 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
430 wpa_s, NULL);
433 wpas_wps_deinit(wpa_s);
435 wpabuf_free(wpa_s->pending_eapol_rx);
436 wpa_s->pending_eapol_rx = NULL;
439 ibss_rsn_deinit(wpa_s->ibss_rsn);
440 wpa_s->ibss_rsn = NULL;
443 sme_deinit(wpa_s);
446 wpa_supplicant_ap_deinit(wpa_s);
450 wpas_p2p_deinit(wpa_s);
454 offchannel_deinit(wpa_s);
457 wpa_supplicant_cancel_sched_scan(wpa_s);
459 os_free(wpa_s->next_scan_freqs);
460 wpa_s->next_scan_freqs = NULL;
462 gas_query_deinit(wpa_s->gas);
463 wpa_s->gas = NULL;
465 free_hw_features(wpa_s);
467 os_free(wpa_s->bssid_filter);
468 wpa_s->bssid_filter = NULL;
470 os_free(wpa_s->disallow_aps_bssid);
471 wpa_s->disallow_aps_bssid = NULL;
472 os_free(wpa_s->disallow_aps_ssid);
473 wpa_s->disallow_aps_ssid = NULL;
475 wnm_bss_keep_alive_deinit(wpa_s);
477 wnm_deallocate_memory(wpa_s);
480 ext_password_deinit(wpa_s->ext_pw);
481 wpa_s->ext_pw = NULL;
483 wpabuf_free(wpa_s->last_gas_resp);
485 os_free(wpa_s->last_scan_res);
486 wpa_s->last_scan_res = NULL;
492 * @wpa_s: Pointer to wpa_supplicant data
498 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
500 if (wpa_s->keys_cleared) {
508 wpa_dbg(wpa_s, MSG_DEBUG, "No keys have been configured - "
514 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
515 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
516 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
517 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
519 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
520 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
523 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
527 wpa_s, addr,
531 wpa_s->keys_cleared = 1;
571 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
573 if (wpas_driver_bss_selection(wpa_s))
575 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
578 bgscan_deinit(wpa_s);
579 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan) {
580 if (bgscan_init(wpa_s, wpa_s->current_ssid)) {
581 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
590 wpa_s->bgscan_ssid = wpa_s->current_ssid;
591 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
594 bgscan_notify_scan(wpa_s, scan_res);
599 wpa_s->bgscan_ssid = NULL;
603 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
605 if (wpa_s->bgscan_ssid != NULL) {
606 bgscan_deinit(wpa_s);
607 wpa_s->bgscan_ssid = NULL;
614 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
616 if (autoscan_init(wpa_s, 0))
617 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
621 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
623 autoscan_deinit(wpa_s);
627 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
629 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
630 wpa_s->wpa_state == WPA_SCANNING) {
631 autoscan_deinit(wpa_s);
632 wpa_supplicant_start_autoscan(wpa_s);
639 * @wpa_s: Pointer to wpa_supplicant data
645 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
648 enum wpa_states old_state = wpa_s->wpa_state;
650 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
651 wpa_supplicant_state_txt(wpa_s->wpa_state),
655 if(state == WPA_ASSOCIATED && wpa_s->current_ssid) {
656 wpa_s->current_ssid->assoc_retry = 0;
661 wpa_supplicant_notify_scanning(wpa_s, 0);
663 if (state == WPA_COMPLETED && wpa_s->new_connection) {
664 struct wpa_ssid *ssid = wpa_s->current_ssid;
666 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
668 MAC2STR(wpa_s->bssid),
672 wpas_clear_temp_disabled(wpa_s, ssid, 1);
673 wpa_s->extra_blacklist_count = 0;
674 wpa_s->new_connection = 0;
675 wpa_drv_set_operstate(wpa_s, 1);
677 wpa_drv_set_supp_port(wpa_s, 1);
679 wpa_s->after_wps = 0;
681 wpas_p2p_completed(wpa_s);
684 sme_sched_obss_scan(wpa_s, 1);
687 wpa_s->new_connection = 1;
688 wpa_drv_set_operstate(wpa_s, 0);
690 wpa_drv_set_supp_port(wpa_s, 0);
692 sme_sched_obss_scan(wpa_s, 0);
694 wpa_s->wpa_state = state;
698 wpa_supplicant_start_bgscan(wpa_s);
700 wpa_supplicant_stop_bgscan(wpa_s);
704 wpa_supplicant_stop_autoscan(wpa_s);
707 wpa_supplicant_start_autoscan(wpa_s);
709 if (wpa_s->wpa_state != old_state) {
710 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
712 if (wpa_s->wpa_state == WPA_COMPLETED ||
714 wpas_notify_auth_changed(wpa_s);
723 struct wpa_supplicant *wpa_s = global->ifaces;
724 while (wpa_s) {
725 if (wpas_wps_terminate_pending(wpa_s) == 1)
727 wpa_s = wpa_s->next;
743 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
745 enum wpa_states old_state = wpa_s->wpa_state;
747 wpa_s->pairwise_cipher = 0;
748 wpa_s->group_cipher = 0;
749 wpa_s->mgmt_group_cipher = 0;
750 wpa_s->key_mgmt = 0;
751 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
752 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
754 if (wpa_s->wpa_state != old_state)
755 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
761 * @wpa_s: Pointer to wpa_supplicant data
770 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
776 if (wpa_s->confname == NULL)
778 conf = wpa_config_read(wpa_s->confname, NULL);
780 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
781 "file '%s' - exiting", wpa_s->confname);
784 wpa_config_read(wpa_s->confanother, conf);
788 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
789 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
791 wpa_s->conf->ctrl_interface) != 0);
793 if (reconf_ctrl && wpa_s->ctrl_iface) {
794 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
795 wpa_s->ctrl_iface = NULL;
798 eapol_sm_invalidate_cached_session(wpa_s->eapol);
799 if (wpa_s->current_ssid) {
800 wpa_supplicant_deauthenticate(wpa_s,
808 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
813 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
815 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
816 wpa_sm_set_config(wpa_s->wpa, NULL);
817 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
818 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
819 rsn_preauth_deinit(wpa_s->wpa);
821 old_ap_scan = wpa_s->conf->ap_scan;
822 wpa_config_free(wpa_s->conf);
823 wpa_s->conf = conf;
824 if (old_ap_scan != wpa_s->conf->ap_scan)
825 wpas_notify_ap_scan_changed(wpa_s);
828 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
830 wpa_supplicant_update_config(wpa_s);
832 wpa_supplicant_clear_status(wpa_s);
833 if (wpa_supplicant_enabled_networks(wpa_s)) {
834 wpa_s->reassociate = 1;
835 wpa_supplicant_req_scan(wpa_s, 0, 0);
837 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
845 struct wpa_supplicant *wpa_s;
846 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
847 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
849 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
884 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
888 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
891 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
897 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
900 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
906 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
912 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
921 wpa_s->conf->pmf : ssid->ieee80211w) ==
923 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
936 * @wpa_s: Pointer to wpa_supplicant data
948 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
967 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
974 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
977 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
984 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
994 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1000 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1005 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1010 wpa_s->wpa_proto = proto;
1011 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1012 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1015 if (bss || !wpa_s->ap_ies_from_associnfo) {
1016 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1018 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1024 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1025 if (wpa_s->group_cipher < 0) {
1026 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1030 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1031 wpa_cipher_txt(wpa_s->group_cipher));
1034 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1035 if (wpa_s->pairwise_cipher < 0) {
1036 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1040 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1041 wpa_cipher_txt(wpa_s->pairwise_cipher));
1045 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1051 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1052 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1054 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1055 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1059 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1060 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1062 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1063 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1067 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1068 wpa_dbg(wpa_s, MSG_DEBUG,
1071 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1072 wpa_dbg(wpa_s, MSG_DEBUG,
1076 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1077 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1079 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1080 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1082 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1083 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1085 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1090 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1091 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1092 wpa_s->pairwise_cipher);
1093 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1098 wpa_s
1102 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1103 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1106 wpa_s->mgmt_group_cipher = 0;
1107 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1109 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1110 wpa_s->mgmt_group_cipher);
1111 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1113 wpa_s->conf->pmf : ssid->ieee80211w));
1116 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1117 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1122 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
1131 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1136 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1142 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1148 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1167 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1172 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1178 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1180 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1192 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1198 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1218 if (wpa_s->conf->interworking)
1232 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf)
1237 if (len < wpa_s->extended_capa_len)
1238 len = wpa_s->extended_capa_len;
1243 wpas_ext_capab_byte(wpa_s, pos, i);
1245 if (i < wpa_s->extended_capa_len) {
1246 *pos &= ~wpa_s->extended_capa_mask[i];
1247 *pos |= wpa_s->extended_capa[i];
1264 * @wpa_s: Pointer to wpa_supplicant data
1270 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1290 ibss_rsn_deinit(wpa_s->ibss_rsn);
1291 wpa_s->ibss_rsn = NULL;
1300 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1301 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1305 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1306 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1308 wpas_p2p_ap_setup_failed(wpa_s);
1311 wpa_s->current_bss = bss;
1313 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1321 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1325 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1327 sme_authenticate(wpa_s, bss, ssid);
1332 wpa_s->reassociate = 0;
1333 if (bss && !wpas_driver_bss_selection(wpa_s)) {
1337 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1340 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1341 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1342 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1344 wpas_notify_bssid_changed(wpa_s);
1349 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1352 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1357 wpa_s->conf->ap_scan == 2 &&
1361 wpa_s->scan_req = MANUAL_SCAN_REQ;
1362 wpa_s->reassociate = 1;
1363 wpa_supplicant_req_scan(wpa_s, 0, 0);
1367 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1369 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1371 wpa_supplicant_cancel_sched_scan(wpa_s);
1372 wpa_supplicant_cancel_scan(wpa_s);
1376 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1388 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1391 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1400 wpa_s->conf->okc :
1403 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1405 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1407 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1409 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1420 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1422 wpa_s->wpa_proto = 0;
1425 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1427 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1442 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1447 wpa_s->wpa_proto = 0;
1450 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1452 wpa_s->wpa_proto = 0;
1456 if (wpa_s->global->p2p) {
1462 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1468 wpa_s->cross_connect_disallowed = 0;
1473 wpa_s->cross_connect_disallowed =
1476 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1478 wpa_s->cross_connect_disallowed ?
1485 if (is_hs20_network(wpa_s, ssid, bss)) {
1498 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab);
1509 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1511 cipher_pairwise = wpa_cipher_to_suite_driver(wpa_s->pairwise_cipher);
1512 cipher_group = wpa_cipher_to_suite_driver(wpa_s->group_cipher);
1513 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1514 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1515 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1517 if (wpa_set_wep_keys(wpa_s, ssid)) {
1522 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1526 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1541 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1543 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1546 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1550 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1565 wpa_s->conf->ap_scan == 2) {
1577 params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1578 params.wpa_proto = wpa_s->wpa_proto;
1589 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1602 wpa_s->conf->pmf : ssid->ieee80211w;
1609 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1619 if (wpa_s->parent->set_sta_uapsd)
1620 params.uapsd = wpa_s->parent->sta_uapsd;
1629 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
1636 if ((wpa_s->num_multichan_concurrent < 2) &&
1637 ((freq = wpa_drv_shared_freq(wpa_s)) > 0) && (freq != params.freq)) {
1640 if (wpas_p2p_handle_frequency_conflicts(wpa_s, params.freq, ssid) < 0)
1644 ret = wpa_drv_associate(wpa_s, ¶ms);
1646 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1648 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1654 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
1655 wpa_s, WPA_DISCONNECTED);
1656 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1664 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1667 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1670 wpa_supplicant_cancel_auth_timeout(wpa_s);
1671 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1674 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1675 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1680 wpa_supplicant_cancel_auth_timeout(wpa_s);
1689 } else if (wpa_s->conf->ap_scan == 1) {
1693 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1697 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
1699 wpa_set_wep_keys(wpa_s, ssid);
1702 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1707 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1709 old_ssid = wpa_s->current_ssid;
1710 wpa_s->current_ssid = ssid;
1711 wpa_s->current_bss = bss;
1712 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1713 wpa_supplicant_initiate_eapol(wpa_s);
1714 if (old_ssid != wpa_s->current_ssid)
1715 wpas_notify_network_changed(wpa_s);
1719 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1724 wpa_clear_keys(wpa_s, addr);
1725 old_ssid = wpa_s->current_ssid;
1726 wpa_supplicant_mark_disassoc(wpa_s);
1727 wpa_sm_set_config(wpa_s->wpa, NULL);
1728 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1729 if (old_ssid != wpa_s->current_ssid)
1730 wpas_notify_network_changed(wpa_s);
1731 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1737 * @wpa_s: Pointer to wpa_supplicant data
1743 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1750 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
1752 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
1753 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
1755 if (!is_zero_ether_addr(wpa_s->bssid))
1756 addr = wpa_s->bssid;
1757 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
1758 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
1759 wpa_s->wpa_state == WPA_ASSOCIATING))
1760 addr = wpa_s->pending_bssid;
1761 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
1768 addr = wpa_s->bssid;
1773 wpa_tdls_teardown_peers(wpa_s->wpa);
1777 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
1781 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
1786 wpa_supplicant_clear_connection(wpa_s, addr);
1789 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
1796 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1797 wpas_notify_network_enabled_changed(wpa_s, ssid);
1803 if (!wpa_s->current_ssid && !wpa_s->disconnected)
1804 wpa_s->reassociate = 1;
1810 * @wpa_s: wpa_supplicant structure for a network interface
1815 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
1819 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
1820 wpa_supplicant_enable_one_network(wpa_s, ssid);
1822 wpa_supplicant_enable_one_network(wpa_s, ssid);
1824 if (wpa_s->reassociate && !wpa_s->disconnected) {
1825 if (wpa_s->sched_scanning) {
1828 wpa_supplicant_cancel_sched_scan(wpa_s);
1831 if (wpa_supplicant_fast_associate(wpa_s) != 1)
1832 wpa_supplicant_req_scan(wpa_s, 0, 0);
1839 * @wpa_s: wpa_supplicant structure for a network interface
1844 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
1851 if (wpa_s->sched_scanning)
1852 wpa_supplicant_cancel_sched_scan(wpa_s);
1854 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1865 wpa_s, other_ssid);
1867 if (wpa_s->current_ssid)
1869 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1871 if (ssid == wpa_s->current_ssid)
1873 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1880 wpas_notify_network_enabled_changed(wpa_s, ssid);
1881 if (wpa_s->sched_scanning) {
1884 wpa_supplicant_cancel_sched_scan(wpa_s);
1885 wpa_supplicant_req_scan(wpa_s, 0, 0);
1894 * @wpa_s: wpa_supplicant structure for a network interface
1897 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
1904 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
1906 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1911 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1917 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1925 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
1928 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
1931 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
1939 wpa_s->current_ssid = ssid;
1940 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1942 wpa_s->connect_without_scan = NULL;
1943 wpa_s->disconnected = 0;
1944 wpa_s->reassociate = 1;
1946 if (wpa_supplicant_fast_associate(wpa_s) != 1)
1947 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
1950 wpas_notify_network_selected(wpa_s, ssid);
1956 * @wpa_s: wpa_supplicant structure for a network interface
1961 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
1970 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
1971 wpa_s->wpa_state >= WPA_ASSOCIATING &&
1972 wpa_s->wpa_state < WPA_COMPLETED) {
1974 "associating", wpa_s->conf->ap_scan, ap_scan);
1979 old_ap_scan = wpa_s->conf->ap_scan;
1980 wpa_s->conf->ap_scan = ap_scan;
1982 if (old_ap_scan != wpa_s->conf->ap_scan)
1983 wpas_notify_ap_scan_changed(wpa_s);
1991 * @wpa_s: wpa_supplicant structure for a network interface
1996 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2000 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2004 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2006 wpa_s->conf->bss_expiration_age = bss_expire_age;
2014 * @wpa_s: wpa_supplicant structure for a network interface
2019 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2023 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2027 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2029 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2037 * @wpa_s: wpa_supplicant structure for a network interface
2042 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2046 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2050 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2052 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
2102 * @wpa_s: Pointer to wpa_supplicant data
2105 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2114 res = wpa_drv_get_ssid(wpa_s, ssid);
2116 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2122 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2123 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2128 wired = wpa_s->conf->ap_scan == 0 &&
2129 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2131 entry = wpa_s->conf->ssid;
2133 if (!wpas_network_disabled(wpa_s, entry) &&
2140 if (!wpas_network_disabled(wpa_s, entry) &&
2148 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2160 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2162 struct wpa_global *global = wpa_s->global;
2173 wpa_s->driver = wpa_drivers[i];
2174 wpa_s->global_drv_priv = global->drv_priv[i];
2180 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2187 if (wpa_s == NULL)
2191 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2198 return select_driver(wpa_s, 0);
2213 if (select_driver(wpa_s, i) == 0)
2221 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2228 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2243 struct wpa_supplicant *wpa_s = ctx;
2245 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2248 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2249 (wpa_s->last_eapol_matches_bssid &&
2251 !wpa_s->ap_iface &&
2253 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
2266 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
2268 wpa_supplicant_state_txt(wpa_s->wpa_state),
2269 MAC2STR(wpa_s->bssid));
2270 wpabuf_free(wpa_s->pending_eapol_rx);
2271 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2272 if (wpa_s->pending_eapol_rx) {
2273 os_get_time(&wpa_s->pending_eapol_rx_time);
2274 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2280 wpa_s->last_eapol_matches_bssid =
2281 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2284 if (wpa_s->ap_iface) {
2285 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2290 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2291 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2296 if (wpa_s->eapol_received == 0 &&
2297 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2298 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2299 wpa_s->wpa_state != WPA_COMPLETED) &&
2300 (wpa_s->current_ssid == NULL ||
2301 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2304 wpa_s,
2305 (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2306 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2307 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2310 wpa_s->eapol_received++;
2312 if (wpa_s->countermeasures) {
2313 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2319 if (wpa_s->current_ssid &&
2320 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2321 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2332 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2333 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2334 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2336 wpa_drv_poll(wpa_s);
2337 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2338 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2339 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2346 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2351 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
2353 if (wpa_s->driver->send_eapol) {
2354 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2356 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2357 } else if ((!wpa_s->p2p_mgmt ||
2358 !(wpa_s->drv_flags &
2360 !(wpa_s->drv_flags &
2362 l2_packet_deinit(wpa_s->l2);
2363 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2364 wpa_drv_get_mac_addr(wpa_s),
2366 wpa_supplicant_rx_eapol, wpa_s, 0);
2367 if (wpa_s->l2 == NULL)
2370 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2372 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2375 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2376 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2387 struct wpa_supplicant *wpa_s = ctx;
2394 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2396 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2402 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2404 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2411 * @wpa_s: Pointer to wpa_supplicant data
2418 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2422 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2425 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2426 MAC2STR(wpa_s->own_addr));
2427 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2429 if (wpa_s->bridge_ifname[0]) {
2430 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2431 "interface '%s'", wpa_s->bridge_ifname);
2432 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2433 wpa_s->own_addr,
2436 wpa_s, 1);
2437 if (wpa_s->l2_br == NULL) {
2438 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2440 wpa_s->bridge_ifname);
2445 wpa_clear_keys(wpa_s, NULL);
2449 wpa_drv_set_countermeasures(wpa_s, 0);
2451 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2452 wpa_drv_flush_pmkid(wpa_s);
2454 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2455 wpa_s->prev_scan_wildcard = 0;
2457 if (wpa_supplicant_enabled_networks(wpa_s)) {
2458 if (wpa_supplicant_delayed_sched_scan(wpa_s, interface_count,
2460 wpa_supplicant_req_scan(wpa_s, interface_count,
2464 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2479 struct wpa_supplicant *wpa_s;
2481 wpa_s = os_zalloc(sizeof(*wpa_s));
2482 if (wpa_s == NULL)
2484 wpa_s->scan_req = INITIAL_SCAN_REQ;
2485 wpa_s->scan_interval = 5;
2486 wpa_s->new_connection = 1;
2487 wpa_s->parent = wpa_s;
2488 wpa_s->sched_scanning = 0;
2490 return wpa_s;
2496 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2513 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2519 wpa_msg(wpa_s, MSG_DEBUG,
2528 wpa_msg(wpa_s, MSG_ERROR,
2550 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2557 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2573 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
2578 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
2584 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
2597 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
2602 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
2608 wpa_msg(wpa_s, MSG_ERROR,
2622 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
2631 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
2644 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
2653 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
2667 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2682 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
2683 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
2685 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
2686 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
2687 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
2688 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
2696 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2742 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
2747 if (!wpa_s->conf->pcsc_reader)
2750 wpa_s->scard = scard_init(SCARD_TRY_BOTH, wpa_s->conf->pcsc_reader);
2751 if (!wpa_s->scard)
2754 if (wpa_s->conf->pcsc_pin &&
2755 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
2756 scard_deinit(wpa_s->scard);
2757 wpa_s->scard = NULL;
2758 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
2762 len = sizeof(wpa_s->imsi) - 1;
2763 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
2764 scard_deinit(wpa_s->scard);
2765 wpa_s->scard = NULL;
2766 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
2769 wpa_s->imsi[len] = '\0';
2771 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
2774 wpa_s->imsi, wpa_s->mnc_len);
2776 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
2777 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
2784 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
2788 ext_password_deinit(wpa_s->ext_pw);
2789 wpa_s->ext_pw = NULL;
2790 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
2792 if (!wpa_s->conf->ext_password_backend)
2795 val = os_strdup(wpa_s->conf->ext_password_backend);
2804 wpa_s->ext_pw = ext_password_init(val, pos);
2806 if (wpa_s->ext_pw == NULL) {
2810 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
2816 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
2831 wpa_s
2832 if (wpa_s->confname == NULL) {
2839 iface->confname, wpa_s->confname);
2841 wpa_s->confname = os_strdup(iface->confname);
2843 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
2844 if (wpa_s->conf == NULL) {
2846 "configuration '%s'.", wpa_s->confname);
2849 wpa_s->confanother = os_rel2abs_path(iface->confanother);
2850 wpa_config_read(wpa_s->confanother, wpa_s->conf);
2857 os_free(wpa_s->conf->ctrl_interface);
2858 wpa_s->conf->ctrl_interface =
2863 os_free(wpa_s->conf->driver_param);
2864 wpa_s->conf->driver_param =
2869 os_free(wpa_s->conf->ctrl_interface);
2870 wpa_s->conf->ctrl_interface = NULL;
2873 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
2876 if (wpa_s->conf == NULL) {
2885 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
2890 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
2894 sizeof(wpa_s->bridge_ifname)) {
2899 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
2900 sizeof(wpa_s->bridge_ifname));
2904 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
2905 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
2913 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
2916 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
2917 if (wpa_s->drv_priv == NULL) {
2921 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
2926 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
2930 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
2931 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
2932 "driver_param '%s'", wpa_s->conf->driver_param);
2936 ifname = wpa_drv_get_ifname(wpa_s);
2937 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
2938 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
2940 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2943 if (wpa_supplicant_init_wpa(wpa_s) < 0)
2946 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
2947 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
2949 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
2951 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
2952 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
2953 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
2954 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2959 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
2960 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
2961 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
2962 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2967 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
2968 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
2969 wpa_s->conf->dot11RSNAConfigSATimeout)) {
2970 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2975 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
2976 &wpa_s->hw.num_modes,
2977 &wpa_s->hw.flags);
2979 if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
2980 wpa_s->drv_capa_known = 1;
2981 wpa_s->drv_flags = capa.flags;
2982 wpa_s->drv_enc = capa.enc;
2983 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
2984 wpa_s->max_scan_ssids = capa.max_scan_ssids;
2985 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
2986 wpa_s->sched_scan_supported = capa.sched_scan_supported;
2987 wpa_s->max_match_sets = capa.max_match_sets;
2988 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
2989 wpa_s->max_stations = capa.max_stations;
2990 wpa_s->extended_capa = capa.extended_capa;
2991 wpa_s->extended_capa_mask = capa.extended_capa_mask;
2992 wpa_s->extended_capa_len = capa.extended_capa_len;
2993 wpa_s->num_multichan_concurrent =
2996 if (wpa_s->max_remain_on_chan == 0)
2997 wpa_s->max_remain_on_chan = 1000;
3004 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
3005 wpa_s->p2p_mgmt = iface->p2p_mgmt;
3009 if (wpa_s->num_multichan_concurrent == 0)
3010 wpa_s->num_multichan_concurrent = 1;
3012 if (wpa_supplicant_driver_init(wpa_s) < 0)
3017 !(wpa_s->drv_flags &
3019 wpa_tdls_init(wpa_s->wpa))
3023 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3024 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
3025 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
3029 if (wpas_wps_init(wpa_s))
3032 if (wpa_supplicant_init_eapol(wpa_s) < 0)
3034 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3036 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3037 if (wpa_s->ctrl_iface == NULL) {
3046 wpa_s->conf->ctrl_interface);
3050 wpa_s->gas = gas_query_init(wpa_s);
3051 if (wpa_s->gas == NULL) {
3057 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
3058 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
3063 if (wpa_bss_init(wpa_s) < 0)
3069 wpa_s->mnc_len = eap_proxy_get_imsi(wpa_s->imsi, &len);
3070 if (wpa_s->mnc_len > 0) {
3071 wpa_s->imsi[len] = '\0';
3073 wpa_s->imsi, wpa_s->mnc_len);
3080 if (pcsc_reader_init(wpa_s) < 0)
3083 if (wpas_init_ext_pw(wpa_s) < 0)
3090 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
3093 wpa_s->disconnected = 1;
3094 if (wpa_s->drv_priv) {
3095 wpa_supplicant_deauthenticate(wpa_s,
3098 wpa_drv_set_countermeasures(wpa_s, 0);
3099 wpa_clear_keys(wpa_s, NULL);
3102 wpa_supplicant_cleanup(wpa_s);
3105 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
3106 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
3108 wpas_p2p_deinit_global(wpa_s->global);
3112 if (wpa_s->drv_priv)
3113 wpa_drv_deinit(wpa_s);
3116 wpas_notify_iface_removed(wpa_s);
3119 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
3121 if (wpa_s->ctrl_iface) {
3122 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3123 wpa_s->ctrl_iface = NULL;
3126 if (wpa_s->conf != NULL) {
3127 wpa_config_free(wpa_s->conf);
3128 wpa_s->conf = NULL;
3131 os_free(wpa_s);
3150 struct wpa_supplicant *wpa_s;
3157 wpa_s = wpa_supplicant_alloc();
3158 if (wpa_s == NULL)
3161 wpa_s->global = global;
3178 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
3181 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
3186 if (wpas_notify_iface_added(wpa_s)) {
3187 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
3191 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3192 wpas_notify_network_added(wpa_s, ssid);
3194 wpa_s->next = global->ifaces;
3195 global->ifaces = wpa_s;
3197 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
3198 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3200 return wpa_s;
3207 * @wpa_s: Pointer to the network interface to be removed
3216 struct wpa_supplicant *wpa_s,
3223 if (prev == wpa_s) {
3224 global->ifaces = wpa_s->next;
3226 while (prev && prev->next != wpa_s)
3230 prev->next = wpa_s->next;
3233 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3235 if (global->p2p_group_formation == wpa_s)
3237 if (global->p2p_invite_group == wpa_s)
3239 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
3247 * @wpa_s: Pointer to the network interface
3250 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3254 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3255 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3259 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
3276 struct wpa_supplicant *wpa_s;
3278 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3279 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3280 return wpa_s;
3289 struct wpa_supplicant *wpa_s = ctx;
3290 if (wpa_s == NULL)
3292 return wpa_s->ifname;
3432 struct wpa_supplicant *wpa_s;
3439 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
3440 if (wpa_s->ctrl_iface)
3442 wpa_s->ctrl_iface);
3515 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
3517 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
3518 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3520 country[0] = wpa_s->conf->country[0];
3521 country[1] = wpa_s->conf->country[1];
3523 if (wpa_drv_set_country(wpa_s, country) < 0) {
3529 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
3530 wpas_init_ext_pw(wpa_s);
3533 wpas_wps_update_config(wpa_s);
3537 wpas_p2p_update_config(wpa_s);
3540 wpa_s->conf->changed_parameters = 0;
3558 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
3569 cbss = wpa_s->current_bss;
3571 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
3576 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
3592 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
3601 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
3603 if (wpa_s->disconnected) {
3608 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
3622 count = wpa_blacklist_add(wpa_s, bssid);
3623 if (count == 1 && wpa_s->current_bss) {
3630 freqs = get_bss_freqs_in_ess(wpa_s);
3632 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
3634 wpa_blacklist_add(wpa_s, bssid);
3640 os_free(wpa_s->next_scan_freqs);
3641 wpa_s->next_scan_freqs = freqs;
3649 count += wpa_s->extra_blacklist_count;
3651 if (count > 3 && wpa_s->current_ssid) {
3654 wpas_auth_failed(wpa_s);
3675 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
3682 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
3685 wpas_p2p_continue_after_scan(wpa_s);
3689 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
3691 return wpa_s->conf->ap_scan == 2 ||
3692 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
3697 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
3715 if (ssid == wpa_s->current_ssid)
3716 wpa_s->reassociate = 1;
3723 if (ssid == wpa_s->current_ssid)
3724 wpa_s->reassociate = 1;
3731 if (ssid == wpa_s->current_ssid)
3732 wpa_s->reassociate = 1;
3738 if (ssid == wpa_s->current_ssid)
3739 wpa_s->reassociate = 1;
3753 if (ssid == wpa_s->current_ssid)
3754 wpa_s->reassociate = 1;
3770 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
3781 if (wpa_s && wpa_s->drv_capa_known)
3782 drv_enc = wpa_s->drv_enc;
3807 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
3809 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
3811 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
3817 void wpas_auth_failed(struct wpa_supplicant *wpa_s)
3819 struct wpa_ssid *ssid = wpa_s->current_ssid;
3836 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
3864 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
3871 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
3878 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
3889 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
3893 if (wpa_s->disallow_aps_bssid == NULL)
3896 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
3897 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
3906 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
3911 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
3914 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
3915 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
3927 * @wpa_s: Pointer to the network interface
3933 void wpas_request_connection(struct wpa_supplicant *wpa_s)
3935 wpa_s->normal_scans = 0;
3936 wpa_supplicant_reinit_autoscan(wpa_s);
3937 wpa_s->extra_blacklist_count = 0;
3938 wpa_s->disconnected = 0;
3939 wpa_s->reassociate = 1;
3941 if (wpa_supplicant_fast_associate(wpa_s) != 1)
3942 wpa_supplicant_req_scan(wpa_s, 0, 0);
3948 * @wpa_s: Pointer to wpa_supplicant data
3954 int wpas_wpa_is_in_progress(struct wpa_supplicant *wpa_s)
3959 if (!wpa_s->driver->get_radio_name)
3962 rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
3966 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
3967 if (ifs == wpa_s || !ifs->driver->get_radio_name)
3975 wpa_dbg(wpa_s, MSG_DEBUG, "Connection is in progress "
3989 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
4001 if (wpa_s->current_ssid != NULL && wpa_s->assoc_freq != 0) {
4002 if (wpa_s->current_ssid->mode == WPAS_MODE_AP ||
4003 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO)
4004 freq_array[idx++] = wpa_s->current_ssid->frequency;
4005 else if (wpa_drv_get_bssid(wpa_s, bssid) == 0)
4006 freq_array[idx++] = wpa_s->assoc_freq;
4010 if (!wpa_s->driver->get_radio_name) {
4011 freq = wpa_drv_shared_freq(wpa_s);
4018 rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
4022 for (ifs = wpa_s->global->ifaces, idx = 0; ifs && idx < len;
4024 if (wpa_s == ifs || !ifs->driver->get_radio_name)
