Lines Matching refs:wpa_s
112 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
121 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
130 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
142 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
148 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
153 switch (wpa_s->group_cipher) {
172 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
173 "WPA-None", wpa_s->group_cipher);
180 return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
186 struct wpa_supplicant *wpa_s = eloop_ctx;
187 const u8 *bssid = wpa_s->bssid;
189 bssid = wpa_s->pending_bssid;
190 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
192 wpa_blacklist_add(wpa_s, bssid);
193 wpa_sm_notify_disassoc(wpa_s->wpa);
194 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
195 wpa_s->reassociate = 1;
201 wpa_supplicant_req_scan(wpa_s, 1, 0);
207 * @wpa_s: Pointer to wpa_supplicant data
214 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
217 if (wpa_s->conf->ap_scan == 0 &&
218 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
221 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
223 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
224 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
230 * @wpa_s: Pointer to wpa_supplicant data
236 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
238 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
239 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
240 wpa_blacklist_del(wpa_s, wpa_s->bssid);
246 * @wpa_s: Pointer to wpa_supplicant data
251 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
255 struct wpa_ssid *ssid = wpa_s->current_ssid;
259 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
260 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
265 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
266 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
267 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
272 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
273 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
275 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
276 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
277 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
279 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
282 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
293 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
296 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
299 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
300 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
301 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
302 eapol_conf.external_sim = wpa_s->conf->external_sim;
303 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
306 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
312 * @wpa_s: Pointer to wpa_supplicant data
319 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
325 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
327 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
329 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
330 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
331 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
332 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
333 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
334 wpa_s->group_cipher = WPA_CIPHER_NONE;
335 wpa_s->mgmt_group_cipher = 0;
339 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
340 wpa_s->group_cipher = WPA_CIPHER_WEP104;
343 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
344 wpa_s->group_cipher = WPA_CIPHER_WEP40;
349 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
350 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
351 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
352 wpa_s->pairwise_cipher);
353 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
355 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
356 wpa_s->mgmt_group_cipher);
359 pmksa_cache_clear_current(wpa_s->wpa);
363 void free_hw_features(struct wpa_supplicant *wpa_s)
366 if (wpa_s->hw.modes == NULL)
369 for (i = 0; i < wpa_s->hw.num_modes; i++) {
370 os_free(wpa_s->hw.modes[i].channels);
371 os_free(wpa_s->hw.modes[i].rates);
374 os_free(wpa_s->hw.modes);
375 wpa_s->hw.modes = NULL;
379 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
383 bgscan_deinit(wpa_s);
384 autoscan_deinit(wpa_s);
385 scard_deinit(wpa_s->scard);
386 wpa_s->scard = NULL;
387 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
388 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
389 l2_packet_deinit(wpa_s->l2);
390 wpa_s->l2 = NULL;
391 if (wpa_s->l2_br) {
392 l2_packet_deinit(wpa_s->l2_br);
393 wpa_s->l2_br = NULL;
396 if (wpa_s->conf != NULL) {
398 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
399 wpas_notify_network_removed(wpa_s, ssid);
402 os_free(wpa_s->confname);
403 wpa_s->confname = NULL;
405 os_free(wpa_s->confanother);
406 wpa_s->confanother = NULL;
409 os_free(wpa_s->conf_p2p_dev);
410 wpa_s->conf_p2p_dev = NULL;
413 wpa_sm_set_eapol(wpa_s->wpa, NULL);
414 eapol_sm_deinit(wpa_s->eapol);
415 wpa_s->eapol = NULL;
417 rsn_preauth_deinit(wpa_s->wpa);
420 wpa_tdls_deinit(wpa_s->wpa);
423 pmksa_candidate_free(wpa_s->wpa);
424 wpa_sm_deinit(wpa_s->wpa);
425 wpa_s->wpa = NULL;
426 wpa_blacklist_clear(wpa_s);
428 wpa_bss_deinit(wpa_s);
430 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
431 wpa_supplicant_cancel_scan(wpa_s);
432 wpa_supplicant_cancel_auth_timeout(wpa_s);
433 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
436 wpa_s, NULL);
439 wpas_wps_deinit(wpa_s);
441 wpabuf_free(wpa_s->pending_eapol_rx);
442 wpa_s->pending_eapol_rx = NULL;
445 ibss_rsn_deinit(wpa_s->ibss_rsn);
446 wpa_s->ibss_rsn = NULL;
449 sme_deinit(wpa_s);
452 wpa_supplicant_ap_deinit(wpa_s);
455 wpas_p2p_deinit(wpa_s);
458 offchannel_deinit(wpa_s);
461 wpa_supplicant_cancel_sched_scan(wpa_s);
463 os_free(wpa_s->next_scan_freqs);
464 wpa_s->next_scan_freqs = NULL;
466 os_free(wpa_s->manual_scan_freqs);
467 wpa_s->manual_scan_freqs = NULL;
469 os_free(wpa_s->manual_sched_scan_freqs);
470 wpa_s->manual_sched_scan_freqs = NULL;
472 gas_query_deinit(wpa_s->gas);
473 wpa_s->gas = NULL;
475 free_hw_features(wpa_s);
477 ieee802_1x_dealloc_kay_sm(wpa_s);
479 os_free(wpa_s->bssid_filter);
480 wpa_s->bssid_filter = NULL;
482 os_free(wpa_s->disallow_aps_bssid);
483 wpa_s->disallow_aps_bssid = NULL;
484 os_free(wpa_s->disallow_aps_ssid);
485 wpa_s->disallow_aps_ssid = NULL;
487 wnm_bss_keep_alive_deinit(wpa_s);
489 wnm_deallocate_memory(wpa_s);
492 ext_password_deinit(wpa_s->ext_pw);
493 wpa_s->ext_pw = NULL;
495 wpabuf_free(wpa_s->last_gas_resp);
496 wpa_s->last_gas_resp = NULL;
497 wpabuf_free(wpa_s->prev_gas_resp);
498 wpa_s->prev_gas_resp = NULL;
500 os_free(wpa_s->last_scan_res);
501 wpa_s->last_scan_res = NULL;
504 hs20_deinit(wpa_s);
508 wpabuf_free(wpa_s->vendor_elem[i]);
509 wpa_s->vendor_elem[i] = NULL;
516 * @wpa_s: Pointer to wpa_supplicant data
522 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
534 if (wpa_s->keys_cleared & BIT(i))
536 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
539 if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
541 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
545 wpa_s, addr,
549 wpa_s->keys_cleared = (u32) -1;
589 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
593 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
594 name = wpa_s->current_ssid->bgscan;
596 name = wpa_s->conf->bgscan;
599 if (wpas_driver_bss_selection(wpa_s))
601 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
604 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
608 bgscan_deinit(wpa_s);
609 if (wpa_s->current_ssid) {
610 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
611 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
620 wpa_s->bgscan_ssid = wpa_s->current_ssid;
621 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
624 bgscan_notify_scan(wpa_s, scan_res);
629 wpa_s->bgscan_ssid = NULL;
633 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
635 if (wpa_s->bgscan_ssid != NULL) {
636 bgscan_deinit(wpa_s);
637 wpa_s->bgscan_ssid = NULL;
644 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
646 if (autoscan_init(wpa_s, 0))
647 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
651 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
653 autoscan_deinit(wpa_s);
657 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
659 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
660 wpa_s->wpa_state == WPA_SCANNING) {
661 autoscan_deinit(wpa_s);
662 wpa_supplicant_start_autoscan(wpa_s);
669 * @wpa_s: Pointer to wpa_supplicant data
675 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
678 enum wpa_states old_state = wpa_s->wpa_state;
680 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
681 wpa_supplicant_state_txt(wpa_s->wpa_state),
686 wpa_s->normal_scans = 0;
690 wpas_connect_work_done(wpa_s);
692 wpa_s->normal_scans = 0;
696 wpa_supplicant_notify_scanning(wpa_s, 0);
698 if (state == WPA_COMPLETED && wpa_s->new_connection) {
699 struct wpa_ssid *ssid = wpa_s->current_ssid;
701 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
703 MAC2STR(wpa_s->bssid),
707 wpas_clear_temp_disabled(wpa_s, ssid, 1);
708 wpa_s->extra_blacklist_count = 0;
709 wpa_s->new_connection = 0;
710 wpa_drv_set_operstate(wpa_s, 1);
712 wpa_drv_set_supp_port(wpa_s, 1);
714 wpa_s->after_wps = 0;
715 wpa_s->known_wps_freq = 0;
716 wpas_p2p_completed(wpa_s);
718 sme_sched_obss_scan(wpa_s, 1);
721 wpa_s->new_connection = 1;
722 wpa_drv_set_operstate(wpa_s, 0);
724 wpa_drv_set_supp_port(wpa_s, 0);
726 sme_sched_obss_scan(wpa_s, 0);
728 wpa_s->wpa_state = state;
732 wpa_supplicant_start_bgscan(wpa_s);
734 wpa_supplicant_stop_bgscan(wpa_s);
738 wpa_supplicant_stop_autoscan(wpa_s);
741 wpa_supplicant_start_autoscan(wpa_s);
743 if (wpa_s->wpa_state != old_state) {
744 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
750 wpas_p2p_indicate_state_change(wpa_s);
752 if (wpa_s->wpa_state == WPA_COMPLETED ||
754 wpas_notify_auth_changed(wpa_s);
763 struct wpa_supplicant *wpa_s = global->ifaces;
764 while (wpa_s) {
765 struct wpa_supplicant *next = wpa_s->next;
766 if (wpas_wps_terminate_pending(wpa_s) == 1)
769 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
770 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
771 wpas_p2p_disconnect(wpa_s);
773 wpa_s = next;
789 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
791 enum wpa_states old_state = wpa_s->wpa_state;
793 wpa_s->pairwise_cipher = 0;
794 wpa_s->group_cipher = 0;
795 wpa_s->mgmt_group_cipher = 0;
796 wpa_s->key_mgmt = 0;
797 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
798 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
800 if (wpa_s->wpa_state != old_state)
801 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
807 * @wpa_s: Pointer to wpa_supplicant data
816 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
822 if (wpa_s->confname == NULL)
824 conf = wpa_config_read(wpa_s->confname, NULL);
826 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
827 "file '%s' - exiting", wpa_s->confname);
830 wpa_config_read(wpa_s->confanother, conf);
834 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
835 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
837 wpa_s->conf->ctrl_interface) != 0);
839 if (reconf_ctrl && wpa_s->ctrl_iface) {
840 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
841 wpa_s->ctrl_iface = NULL;
844 eapol_sm_invalidate_cached_session(wpa_s->eapol);
845 if (wpa_s->current_ssid) {
846 wpa_supplicant_deauthenticate(wpa_s,
854 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
859 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
861 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
862 wpa_sm_set_config(wpa_s->wpa, NULL);
863 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
864 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
865 rsn_preauth_deinit(wpa_s->wpa);
867 old_ap_scan = wpa_s->conf->ap_scan;
868 wpa_config_free(wpa_s->conf);
869 wpa_s->conf = conf;
870 if (old_ap_scan != wpa_s->conf->ap_scan)
871 wpas_notify_ap_scan_changed(wpa_s);
874 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
876 wpa_supplicant_update_config(wpa_s);
878 wpa_supplicant_clear_status(wpa_s);
879 if (wpa_supplicant_enabled_networks(wpa_s)) {
880 wpa_s->reassociate = 1;
881 wpa_supplicant_req_scan(wpa_s, 0, 0);
883 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
891 struct wpa_supplicant *wpa_s;
892 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
893 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
895 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
902 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
906 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
909 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
915 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
918 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
924 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
930 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
939 wpa_s->conf->pmf : ssid->ieee80211w) ==
941 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
954 * @wpa_s: Pointer to wpa_supplicant data
966 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
986 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
993 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
997 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1006 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1015 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1025 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1031 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1036 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1041 wpa_s->wpa_proto = proto;
1042 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1043 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1046 if (bss || !wpa_s->ap_ies_from_associnfo) {
1047 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1049 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1055 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1056 if (wpa_s->group_cipher < 0) {
1057 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1061 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1062 wpa_cipher_txt(wpa_s->group_cipher));
1065 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1066 if (wpa_s->pairwise_cipher < 0) {
1067 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1071 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1072 wpa_cipher_txt(wpa_s->pairwise_cipher));
1076 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1082 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1083 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1085 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1086 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1090 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1091 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1093 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1094 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1098 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1099 wpa_dbg(wpa_s, MSG_DEBUG,
1102 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1103 wpa_dbg(wpa_s, MSG_DEBUG,
1107 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1108 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1110 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1111 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1113 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1114 wpa_dbg(wpa_s
1117 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1118 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1121 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1126 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1127 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1128 wpa_s->pairwise_cipher);
1129 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1134 wpa_s->conf->pmf : ssid->ieee80211w) == NO_MGMT_FRAME_PROTECTION ||
1138 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1139 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1142 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1143 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1146 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1147 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1150 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1151 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1154 wpa_s->mgmt_group_cipher = 0;
1155 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1157 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1158 wpa_s->mgmt_group_cipher);
1159 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1161 wpa_s->conf->pmf : ssid->ieee80211w));
1164 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1165 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1170 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
1179 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1184 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1190 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1196 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1215 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1220 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1226 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1228 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1240 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1246 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1266 if (wpa_s->conf->interworking)
1272 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1278 if (wpa_s->conf->hs20)
1288 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1293 if (len < wpa_s->extended_capa_len)
1294 len = wpa_s->extended_capa_len;
1304 wpas_ext_capab_byte(wpa_s, pos, i);
1306 if (i < wpa_s->extended_capa_len) {
1307 *pos &= ~wpa_s->extended_capa_mask[i];
1308 *pos |= wpa_s->extended_capa[i];
1323 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1328 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1337 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1342 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1351 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1354 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1357 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1369 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1372 struct wpa_radio_work *work = wpa_s->connect_work;
1377 wpa_s->connect_work = NULL;
1389 * @wpa_s: Pointer to wpa_supplicant data
1395 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1401 ibss_rsn_deinit(wpa_s->ibss_rsn);
1402 wpa_s->ibss_rsn = NULL;
1408 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1409 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1413 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1414 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1416 wpas_p2p_ap_setup_failed(wpa_s);
1419 wpa_s->current_bss = bss;
1421 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1429 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1433 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1435 sme_authenticate(wpa_s, bss, ssid);
1439 if (wpa_s->connect_work) {
1440 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1444 if (radio_work_pending(wpa_s, "connect")) {
1445 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1456 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1468 struct wpa_supplicant *wpa_s = work->wpa_s;
1489 wpa_s->connect_work = NULL;
1492 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
1499 wpa_s->connect_work = work;
1501 if (!wpas_valid_bss_ssid(wpa_s, bss, ssid)) {
1502 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
1503 wpas_connect_work_done(wpa_s);
1508 wpa_s->reassociate = 0;
1509 wpa_s->eap_expected_failure = 0;
1510 if (bss && !wpas_driver_bss_selection(wpa_s)) {
1514 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1517 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1518 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1519 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1521 wpas_notify_bssid_changed(wpa_s);
1526 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1529 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1534 wpa_s->conf->ap_scan == 2 &&
1538 wpa_s->scan_req = MANUAL_SCAN_REQ;
1539 wpa_s->reassociate = 1;
1540 wpa_supplicant_req_scan(wpa_s, 0, 0);
1544 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1546 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1548 wpa_supplicant_cancel_sched_scan(wpa_s);
1549 wpa_supplicant_cancel_scan(wpa_s);
1553 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1565 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1568 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1577 wpa_s->conf->okc :
1580 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1582 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1584 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1586 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1597 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1599 wpa_s->wpa_proto = 0;
1602 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1604 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1619 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1624 wpa_s->wpa_proto = 0;
1627 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1629 wpa_s->wpa_proto = 0;
1633 if (wpa_s->global->p2p) {
1639 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1645 wpa_s->cross_connect_disallowed = 0;
1650 wpa_s->cross_connect_disallowed =
1653 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1655 wpa_s->cross_connect_disallowed ?
1660 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
1664 if (is_hs20_network(wpa_s, ssid, bss)) {
1668 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
1694 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
1707 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1709 cipher_pairwise = wpa_s->pairwise_cipher;
1710 cipher_group = wpa_s->group_cipher;
1711 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1712 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1713 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1715 if (wpa_set_wep_keys(wpa_s, ssid)) {
1720 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1724 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1739 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1741 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1744 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1748 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1765 wpa_s->conf->ap_scan == 2) {
1778 params.beacon_int = wpa_s->conf->beacon_int;
1785 params.key_mgmt_suite = wpa_s->key_mgmt;
1786 params.wpa_proto = wpa_s->wpa_proto;
1797 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1810 wpa_s->conf->pmf : ssid->ieee80211w;
1817 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1827 if (wpa_s->parent->set_sta_uapsd)
1828 params.uapsd = wpa_s->parent->sta_uapsd;
1837 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
1844 wpa_supplicant_apply_vht_overrides(wpa_s, wpa_s->current_ssid, ¶ms);
1853 if (wpa_s->num_multichan_concurrent < 2) {
1855 num = get_shared_radio_freqs(wpa_s, &freq, 1);
1860 if (wpas_p2p_handle_frequency_conflicts(wpa_s,
1868 ret = wpa_drv_associate(wpa_s, ¶ms);
1870 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1872 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1878 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
1879 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1880 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1888 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1891 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1894 wpa_supplicant_cancel_auth_timeout(wpa_s);
1895 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1898 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1899 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1904 wpa_supplicant_cancel_auth_timeout(wpa_s);
1913 } else if (wpa_s->conf->ap_scan == 1) {
1917 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1921 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
1923 wpa_set_wep_keys(wpa_s, ssid);
1926 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1931 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1933 old_ssid = wpa_s->current_ssid;
1934 wpa_s->current_ssid = ssid;
1935 wpa_s->current_bss = bss;
1936 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1937 wpa_supplicant_initiate_eapol(wpa_s);
1938 if (old_ssid != wpa_s->current_ssid)
1939 wpas_notify_network_changed(wpa_s);
1943 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1948 wpa_clear_keys(wpa_s, addr);
1949 old_ssid = wpa_s->current_ssid;
1950 wpa_supplicant_mark_disassoc(wpa_s);
1951 wpa_sm_set_config(wpa_s->wpa, NULL);
1952 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1953 if (old_ssid != wpa_s->current_ssid)
1954 wpas_notify_network_changed(wpa_s);
1955 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1961 * @wpa_s: Pointer to wpa_supplicant data
1967 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1974 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
1976 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
1977 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
1979 if (!is_zero_ether_addr(wpa_s->bssid))
1980 addr = wpa_s->bssid;
1981 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
1982 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
1983 wpa_s->wpa_state == WPA_ASSOCIATING))
1984 addr = wpa_s->pending_bssid;
1985 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
1992 addr = wpa_s->bssid;
1997 wpa_tdls_teardown_peers(wpa_s->wpa);
2001 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2005 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2010 wpa_supplicant_clear_connection(wpa_s, addr);
2013 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2020 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2021 wpas_notify_network_enabled_changed(wpa_s, ssid);
2027 if (!wpa_s->current_ssid && !wpa_s->disconnected)
2028 wpa_s->reassociate = 1;
2034 * @wpa_s: wpa_supplicant structure for a network interface
2039 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2043 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2044 wpa_supplicant_enable_one_network(wpa_s, ssid);
2046 wpa_supplicant_enable_one_network(wpa_s, ssid);
2048 if (wpa_s->reassociate && !wpa_s->disconnected) {
2049 if (wpa_s->sched_scanning) {
2052 wpa_supplicant_cancel_sched_scan(wpa_s);
2055 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2056 wpa_supplicant_req_scan(wpa_s, 0, 0);
2063 * @wpa_s: wpa_supplicant structure for a network interface
2068 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2075 if (wpa_s->sched_scanning)
2076 wpa_supplicant_cancel_sched_scan(wpa_s);
2078 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2089 wpa_s, other_ssid);
2091 if (wpa_s->current_ssid)
2093 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2095 if (ssid == wpa_s->current_ssid)
2097 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2104 wpas_notify_network_enabled_changed(wpa_s, ssid);
2105 if (wpa_s->sched_scanning) {
2108 wpa_supplicant_cancel_sched_scan(wpa_s);
2109 wpa_supplicant_req_scan(wpa_s, 0, 0);
2118 * @wpa_s: wpa_supplicant structure for a network interface
2121 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2128 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2130 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2135 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2141 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2149 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2152 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2155 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
2163 wpa_s->current_ssid = ssid;
2164 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2166 wpa_s->connect_without_scan = NULL;
2167 wpa_s->disconnected = 0;
2168 wpa_s->reassociate = 1;
2170 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2171 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
2174 wpas_notify_network_selected(wpa_s, ssid);
2180 * @wpa_s: wpa_supplicant structure for a network interface
2189 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
2209 os_free(wpa_s->conf->pkcs11_engine_path);
2210 os_free(wpa_s->conf->pkcs11_module_path);
2211 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2212 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2214 wpa_sm_set_eapol(wpa_s->wpa, NULL);
2215 eapol_sm_deinit(wpa_s->eapol);
2216 wpa_s->eapol = NULL;
2217 if (wpa_supplicant_init_eapol(wpa_s)) {
2220 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2225 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2233 * @wpa_s: wpa_supplicant structure for a network interface
2238 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s
2247 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2248 wpa_s->wpa_state >= WPA_ASSOCIATING &&
2249 wpa_s->wpa_state < WPA_COMPLETED) {
2251 "associating", wpa_s->conf->ap_scan, ap_scan);
2256 old_ap_scan = wpa_s->conf->ap_scan;
2257 wpa_s->conf->ap_scan = ap_scan;
2259 if (old_ap_scan != wpa_s->conf->ap_scan)
2260 wpas_notify_ap_scan_changed(wpa_s);
2268 * @wpa_s: wpa_supplicant structure for a network interface
2273 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2277 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2281 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2283 wpa_s->conf->bss_expiration_age = bss_expire_age;
2291 * @wpa_s: wpa_supplicant structure for a network interface
2296 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2300 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2304 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2306 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2314 * @wpa_s: wpa_supplicant structure for a network interface
2319 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2323 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2327 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2329 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
2379 * @wpa_s: Pointer to wpa_supplicant data
2382 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2391 res = wpa_drv_get_ssid(wpa_s, ssid);
2393 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2399 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2400 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2405 wired = wpa_s->conf->ap_scan == 0 &&
2406 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2408 entry = wpa_s->conf->ssid;
2410 if (!wpas_network_disabled(wpa_s, entry) &&
2417 if (!wpas_network_disabled(wpa_s, entry) &&
2425 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2437 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2439 struct wpa_global *global = wpa_s->global;
2450 wpa_s->driver = wpa_drivers[i];
2451 wpa_s->global_drv_priv = global->drv_priv[i];
2457 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2464 if (wpa_s == NULL)
2468 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2475 return select_driver(wpa_s, 0);
2490 if (select_driver(wpa_s, i) == 0)
2498 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2505 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2520 struct wpa_supplicant *wpa_s = ctx;
2522 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2526 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
2527 wpa_s->current_ssid->peerkey &&
2528 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2529 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
2530 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
2535 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2536 (wpa_s->last_eapol_matches_bssid &&
2538 !wpa_s->ap_iface &&
2540 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
2553 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
2555 wpa_supplicant_state_txt(wpa_s->wpa_state),
2556 MAC2STR(wpa_s->bssid));
2557 wpabuf_free(wpa_s->pending_eapol_rx);
2558 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2559 if (wpa_s->pending_eapol_rx) {
2560 os_get_reltime(&wpa_s->pending_eapol_rx_time);
2561 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2567 wpa_s->last_eapol_matches_bssid =
2568 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2571 if (wpa_s->ap_iface) {
2572 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2577 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2578 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2583 if (wpa_s->eapol_received == 0 &&
2584 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2585 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2586 wpa_s->wpa_state != WPA_COMPLETED) &&
2587 (wpa_s->current_ssid == NULL ||
2588 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2591 wpa_s,
2592 (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2593 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2594 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2597 wpa_s->eapol_received++;
2599 if (wpa_s->countermeasures) {
2600 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2606 if (wpa_s->current_ssid &&
2607 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2608 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2619 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2620 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2621 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2623 wpa_drv_poll(wpa_s);
2624 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2625 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2626 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2633 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2638 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
2640 if (wpa_s->driver->send_eapol) {
2641 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2643 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2644 } else if ((!wpa_s->p2p_mgmt ||
2645 !(wpa_s->drv_flags &
2647 !(wpa_s->drv_flags &
2649 l2_packet_deinit(wpa_s->l2);
2650 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2651 wpa_drv_get_mac_addr(wpa_s),
2653 wpa_supplicant_rx_eapol, wpa_s, 0);
2654 if (wpa_s->l2 == NULL)
2657 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2659 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2662 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2663 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2674 struct wpa_supplicant *wpa_s = ctx;
2681 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2683 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2689 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2691 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2698 * @wpa_s: Pointer to wpa_supplicant data
2705 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2709 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2712 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2713 MAC2STR(wpa_s->own_addr));
2714 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2716 if (wpa_s->bridge_ifname[0]) {
2717 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2718 "interface '%s'", wpa_s->bridge_ifname);
2719 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2720 wpa_s->own_addr,
2723 wpa_s, 1);
2724 if (wpa_s->l2_br == NULL) {
2725 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2727 wpa_s->bridge_ifname);
2732 wpa_clear_keys(wpa_s, NULL);
2736 wpa_drv_set_countermeasures(wpa_s, 0);
2738 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2739 wpa_drv_flush_pmkid(wpa_s);
2741 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2742 wpa_s->prev_scan_wildcard = 0;
2744 if (wpa_supplicant_enabled_networks(wpa_s)) {
2745 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
2746 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2749 if (!wpa_s->p2p_mgmt &&
2750 wpa_supplicant_delayed_sched_scan(wpa_s,
2753 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
2757 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2772 struct wpa_supplicant *wpa_s;
2774 wpa_s = os_zalloc(sizeof(*wpa_s));
2775 if (wpa_s == NULL)
2777 wpa_s->scan_req = INITIAL_SCAN_REQ;
2778 wpa_s->scan_interval = 5;
2779 wpa_s->new_connection = 1;
2780 wpa_s->parent = wpa_s;
2781 wpa_s->sched_scanning = 0;
2783 return wpa_s;
2789 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2806 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2812 wpa_msg(wpa_s, MSG_DEBUG,
2821 wpa_msg(wpa_s, MSG_ERROR,
2843 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2850 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2866 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
2871 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
2877 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
2890 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
2895 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
2901 wpa_msg(wpa_s, MSG_ERROR,
2915 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
2924 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
2937 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
2946 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
2959 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
2967 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
2981 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2996 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
2997 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
2999 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3000 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3001 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3002 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3003 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3017 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3048 wpa_set_ampdu_factor(wpa_s,
3081 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3086 if (!wpa_s->conf->pcsc_reader)
3089 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3090 if (!wpa_s->scard)
3093 if (wpa_s->conf->pcsc_pin &&
3094 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3095 scard_deinit(wpa_s->scard);
3096 wpa_s->scard = NULL;
3097 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3101 len = sizeof(wpa_s->imsi) - 1;
3102 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3103 scard_deinit(wpa_s->scard);
3104 wpa_s->scard = NULL;
3105 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3108 wpa_s->imsi[len] = '\0';
3110 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3113 wpa_s->imsi, wpa_s->mnc_len);
3115 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3116 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3123 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3127 ext_password_deinit(wpa_s->ext_pw);
3128 wpa_s->ext_pw = NULL;
3129 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3131 if (!wpa_s->conf->ext_password_backend)
3134 val = os_strdup(wpa_s->conf->ext_password_backend);
3143 wpa_s->ext_pw = ext_password_init(val, pos);
3145 if (wpa_s->ext_pw == NULL) {
3149 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3155 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
3161 if (!wpa_s->conf->wowlan_triggers)
3164 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
3166 ret = wpa_drv_wowlan(wpa_s, triggers);
3173 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
3176 struct wpa_supplicant *iface = wpa_s->global->ifaces;
3183 wpa_s->ifname, rn);
3184 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3192 wpa_s->ifname, rn ? rn : "N/A");
3201 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3209 if (work->wpa_s->scan_work == work) {
3211 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
3213 work->wpa_s->scan_work = NULL;
3217 if (work->wpa_s->p2p_scan_work == work) {
3219 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
3221 work->wpa_s->p2p_scan_work = NULL;
3235 struct wpa_supplicant *wpa_s;
3244 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
3246 if (wpa_s && wpa_s->external_scan_running) {
3253 wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting radio work '%s'@%p after %ld.%06ld second wait",
3267 * @wpa_s: wpa_supplicant data
3272 void radio_remove_works(struct wpa_supplicant *wpa_s,
3276 struct wpa_radio *radio = wpa_s->radio;
3284 if (!remove_all && work->wpa_s != wpa_s)
3287 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
3294 radio_work_check_next(wpa_s);
3298 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
3300 struct wpa_radio *radio = wpa_s->radio;
3306 wpa_s->ifname, radio->name);
3307 dl_list_del(&wpa_s->radio_list);
3308 radio_remove_works(wpa_s, NULL, 0);
3309 wpa_s->radio = NULL;
3319 void radio_work_check_next(struct wpa_supplicant *wpa_s)
3321 struct wpa_radio *radio = wpa_s->radio;
3332 * @wpa_s: Pointer to wpa_supplicant data
3355 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
3366 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
3370 work->wpa_s = wpa_s;
3374 was_empty = dl_list_empty(&wpa_s->radio->work);
3376 dl_list_add(&wpa_s->radio->work, &work->list);
3378 dl_list_add_tail(&wpa_s->radio->work, &work->list);
3380 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
3381 radio_work_check_next(wpa_s);
3397 struct wpa_supplicant *wpa_s = work->wpa_s;
3403 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
3408 radio_work_check_next(wpa_s);
3412 int radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
3415 struct wpa_radio *radio = wpa_s->radio;
3418 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
3426 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
3433 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
3436 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
3437 if (wpa_s->drv_priv == NULL) {
3441 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
3446 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
3450 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
3451 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
3452 "driver_param '%s'", wpa_s->conf->driver_param);
3456 ifname = wpa_drv_get_ifname(wpa_s);
3457 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
3458 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
3460 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
3463 rn = wpa_driver_get_radio_name(wpa_s);
3467 wpa_s->radio = radio_add_interface(wpa_s, rn);
3468 if (wpa_s->radio == NULL)
3475 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
3489 wpa_s->confname = os_rel2abs_path(iface->confname);
3490 if (wpa_s->confname == NULL) {
3497 iface->confname, wpa_s->confname);
3499 wpa_s->confname = os_strdup(iface->confname);
3501 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
3502 if (wpa_s->conf == NULL) {
3504 "configuration '%s'.", wpa_s->confname);
3507 wpa_s->confanother = os_rel2abs_path(iface->confanother);
3508 wpa_config_read(wpa_s->confanother, wpa_s->conf);
3511 wpa_s->conf_p2p_dev = os_rel2abs_path(iface->conf_p2p_dev);
3513 wpa_config_read(wpa_s->conf_p2p_dev, wpa_s->conf);
3522 os_free(wpa_s->conf->ctrl_interface);
3523 wpa_s->conf->ctrl_interface =
3528 os_free(wpa_s->conf->driver_param);
3529 wpa_s->conf->driver_param =
3534 os_free(wpa_s->conf->ctrl_interface);
3535 wpa_s->conf->ctrl_interface = NULL;
3538 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
3541 if (wpa_s->conf == NULL) {
3550 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
3555 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
3559 sizeof(wpa_s->bridge_ifname)) {
3564 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
3565 sizeof(wpa_s->bridge_ifname));
3569 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
3570 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
3576 if (wpas_init_driver(wpa_s, iface) < 0)
3579 if (wpa_supplicant_init_wpa(wpa_s) < 0)
3582 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
3583 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
3585 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
3587 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
3588 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
3589 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
3590 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3595 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
3596 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
3597 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
3598 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3603 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
3604 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
3605 wpa_s->conf->dot11RSNAConfigSATimeout)) {
3606 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3611 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
3612 &wpa_s->hw.num_modes,
3613 &wpa_s->hw.flags);
3615 if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
3616 wpa_s->drv_capa_known = 1;
3617 wpa_s->drv_flags = capa.flags;
3618 wpa_s->drv_enc = capa.enc;
3619 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
3620 wpa_s->max_scan_ssids = capa.max_scan_ssids;
3621 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
3622 wpa_s->sched_scan_supported = capa.sched_scan_supported;
3623 wpa_s->max_match_sets = capa.max_match_sets;
3624 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
3625 wpa_s->max_stations = capa.max_stations;
3626 wpa_s->extended_capa = capa.extended_capa;
3627 wpa_s->extended_capa_mask = capa.extended_capa_mask;
3628 wpa_s->extended_capa_len = capa.extended_capa_len;
3629 wpa_s->num_multichan_concurrent =
3632 if (wpa_s->max_remain_on_chan == 0)
3633 wpa_s->max_remain_on_chan = 1000;
3640 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
3641 wpa_s->p2p_mgmt = iface->p2p_mgmt;
3645 if (wpa_s->num_multichan_concurrent == 0)
3646 wpa_s->num_multichan_concurrent = 1;
3648 if (wpa_supplicant_driver_init(wpa_s) < 0)
3653 !(wpa_s->drv_flags &
3655 wpa_tdls_init(wpa_s->wpa))
3659 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3660 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
3661 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
3665 if (wpas_wps_init(wpa_s))
3668 if (wpa_supplicant_init_eapol(wpa_s) < 0)
3670 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3672 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3673 if (wpa_s->ctrl_iface == NULL) {
3682 wpa_s->conf->ctrl_interface);
3686 wpa_s->gas = gas_query_init(wpa_s);
3687 if (wpa_s->gas == NULL) {
3692 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
3693 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
3697 if (wpa_bss_init(wpa_s) < 0)
3705 if (wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
3711 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
3713 if (wpa_s->mnc_len > 0) {
3714 wpa_s->imsi[len] = '\0';
3716 wpa_s->imsi, wpa_s->mnc_len);
3723 if (pcsc_reader_init(wpa_s) < 0)
3726 if (wpas_init_ext_pw(wpa_s) < 0)
3733 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
3736 wpa_s->disconnected = 1;
3737 if (wpa_s->drv_priv) {
3738 wpa_supplicant_deauthenticate(wpa_s,
3741 wpa_drv_set_countermeasures(wpa_s, 0);
3742 wpa_clear_keys(wpa_s, NULL);
3745 wpa_supplicant_cleanup(wpa_s);
3746 wpas_p2p_deinit_iface(wpa_s);
3748 wpas_ctrl_radio_work_flush(wpa_s);
3749 radio_remove_interface(wpa_s);
3751 if (wpa_s->drv_priv)
3752 wpa_drv_deinit(wpa_s);
3755 wpas_notify_iface_removed(wpa_s);
3758 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
3760 if (wpa_s->ctrl_iface) {
3761 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3762 wpa_s->ctrl_iface = NULL;
3765 if (wpa_s->conf != NULL) {
3766 wpa_config_free(wpa_s->conf);
3767 wpa_s->conf = NULL;
3770 os_free(wpa_s);
3789 struct wpa_supplicant *wpa_s;
3796 wpa_s = wpa_supplicant_alloc();
3797 if (wpa_s == NULL)
3800 wpa_s->global = global;
3817 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
3820 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
3825 if (wpas_notify_iface_added(wpa_s)) {
3826 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
3830 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3831 wpas_notify_network_added(wpa_s, ssid);
3833 wpa_s->next = global->ifaces;
3834 global->ifaces = wpa_s;
3836 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
3837 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3839 return wpa_s;
3846 * @wpa_s: Pointer to the network interface to be removed
3855 struct wpa_supplicant *wpa_s,
3862 if (prev == wpa_s) {
3863 global->ifaces = wpa_s->next;
3865 while (prev && prev->next != wpa_s)
3869 prev->next = wpa_s->next;
3872 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3874 if (global->p2p_group_formation == wpa_s)
3876 if (global->p2p_invite_group == wpa_s)
3878 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
3886 * @wpa_s: Pointer to the network interface
3889 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3893 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3894 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3898 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
3915 struct wpa_supplicant *wpa_s;
3917 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3918 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3919 return wpa_s;
3928 struct wpa_supplicant *wpa_s = ctx;
3929 if (wpa_s == NULL)
3931 return wpa_s->ifname;
4071 struct wpa_supplicant *wpa_s;
4078 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
4079 if (wpa_s->ctrl_iface)
4081 wpa_s->ctrl_iface);
4155 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
4157 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
4158 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
4160 country[0] = wpa_s->conf->country[0];
4161 country[1] = wpa_s->conf->country[1];
4163 if (wpa_drv_set_country(wpa_s, country) < 0) {
4169 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
4170 wpas_init_ext_pw(wpa_s);
4173 wpas_wps_update_config(wpa_s);
4175 wpas_p2p_update_config(wpa_s);
4176 wpa_s->conf->changed_parameters = 0;
4194 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
4205 cbss = wpa_s->current_bss;
4207 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
4212 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
4228 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
4234 wpas_connect_work_done(wpa_s);
4239 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
4241 if (wpa_s->disconnected) {
4246 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
4260 count = wpa_blacklist_add(wpa_s, bssid);
4261 if (count == 1 && wpa_s->current_bss) {
4268 freqs = get_bss_freqs_in_ess(wpa_s);
4270 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
4272 wpa_blacklist_add(wpa_s, bssid);
4278 os_free(wpa_s->next_scan_freqs);
4279 wpa_s->next_scan_freqs = freqs;
4287 count += wpa_s->extra_blacklist_count;
4289 if (count > 3 && wpa_s->current_ssid) {
4292 wpas_auth_failed(wpa_s, "CONN_FAILED");
4313 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
4320 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
4325 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
4327 return wpa_s->conf->ap_scan == 2 ||
4328 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
4333 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
4351 if (ssid == wpa_s->current_ssid)
4352 wpa_s->reassociate = 1;
4359 if (ssid == wpa_s->current_ssid)
4360 wpa_s->reassociate = 1;
4367 if (ssid == wpa_s->current_ssid)
4368 wpa_s->reassociate = 1;
4374 if (ssid == wpa_s->current_ssid)
4375 wpa_s->reassociate = 1;
4389 if (ssid == wpa_s->current_ssid)
4390 wpa_s->reassociate = 1;
4410 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
4421 if (wpa_s && wpa_s->drv_capa_known)
4422 drv_enc = wpa_s->drv_enc;
4447 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
4449 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
4451 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
4457 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
4459 struct wpa_ssid *ssid = wpa_s->current_ssid;
4476 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
4510 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
4517 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
4524 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
4535 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
4539 if (wpa_s->disallow_aps_bssid == NULL)
4542 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
4543 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
4552 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
4557 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
4560 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
4561 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
4573 * @wpa_s: Pointer to the network interface
4579 void wpas_request_connection(struct wpa_supplicant *wpa_s)
4581 wpa_s->normal_scans = 0;
4582 wpa_supplicant_reinit_autoscan(wpa_s);
4583 wpa_s->extra_blacklist_count = 0;
4584 wpa_s->disconnected = 0;
4585 wpa_s->reassociate = 1;
4587 if (wpa_supplicant_fast_associate(wpa_s) != 1)
4588 wpa_supplicant_req_scan(wpa_s, 0, 0);
4592 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
4598 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
4602 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
4613 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
4622 wpa_dbg(wpa_s, MSG_DEBUG,
4626 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
4657 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
4666 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
4678 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
