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_conf.wps = wpa_s->key_mgmt == WPA_KEY_MGMT_WPS;
304 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
307 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
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)
384 bgscan_deinit(wpa_s);
385 autoscan_deinit(wpa_s);
386 scard_deinit(wpa_s->scard);
387 wpa_s->scard = NULL;
388 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
389 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
390 l2_packet_deinit(wpa_s->l2);
391 wpa_s->l2 = NULL;
392 if (wpa_s->l2_br) {
393 l2_packet_deinit(wpa_s->l2_br);
394 wpa_s->l2_br = NULL;
397 if (wpa_s->conf != NULL) {
399 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
400 wpas_notify_network_removed(wpa_s, ssid);
403 os_free(wpa_s->confname);
404 wpa_s->confname = NULL;
406 os_free(wpa_s->confanother);
407 wpa_s->confanother = NULL;
409 wpa_sm_set_eapol(wpa_s->wpa, NULL);
410 eapol_sm_deinit(wpa_s->eapol);
411 wpa_s->eapol = NULL;
413 rsn_preauth_deinit(wpa_s->wpa);
416 wpa_tdls_deinit(wpa_s->wpa);
419 pmksa_candidate_free(wpa_s->wpa);
420 wpa_sm_deinit(wpa_s->wpa);
421 wpa_s->wpa = NULL;
422 wpa_blacklist_clear(wpa_s);
424 wpa_bss_deinit(wpa_s);
426 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
427 wpa_supplicant_cancel_scan(wpa_s);
428 wpa_supplicant_cancel_auth_timeout(wpa_s);
429 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
432 wpa_s, NULL);
435 wpas_wps_deinit(wpa_s);
437 wpabuf_free(wpa_s->pending_eapol_rx);
438 wpa_s->pending_eapol_rx = NULL;
441 ibss_rsn_deinit(wpa_s->ibss_rsn);
442 wpa_s->ibss_rsn = NULL;
445 sme_deinit(wpa_s);
448 wpa_supplicant_ap_deinit(wpa_s);
451 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 os_free(wpa_s->manual_scan_freqs);
463 wpa_s->manual_scan_freqs = NULL;
465 os_free(wpa_s->manual_sched_scan_freqs);
466 wpa_s->manual_sched_scan_freqs = NULL;
468 gas_query_deinit(wpa_s->gas);
469 wpa_s->gas = NULL;
471 free_hw_features(wpa_s);
473 ieee802_1x_dealloc_kay_sm(wpa_s);
475 os_free(wpa_s->bssid_filter);
476 wpa_s->bssid_filter = NULL;
478 os_free(wpa_s->disallow_aps_bssid);
479 wpa_s->disallow_aps_bssid = NULL;
480 os_free(wpa_s->disallow_aps_ssid);
481 wpa_s->disallow_aps_ssid = NULL;
483 wnm_bss_keep_alive_deinit(wpa_s);
485 wnm_deallocate_memory(wpa_s);
488 ext_password_deinit(wpa_s->ext_pw);
489 wpa_s->ext_pw = NULL;
491 wpabuf_free(wpa_s->last_gas_resp);
492 wpa_s->last_gas_resp = NULL;
493 wpabuf_free(wpa_s->prev_gas_resp);
494 wpa_s->prev_gas_resp = NULL;
496 os_free(wpa_s->last_scan_res);
497 wpa_s->last_scan_res = NULL;
500 hs20_deinit(wpa_s);
504 wpabuf_free(wpa_s->vendor_elem[i]);
505 wpa_s->vendor_elem[i] = NULL;
512 * @wpa_s: Pointer to wpa_supplicant data
518 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
530 if (wpa_s->keys_cleared & BIT(i))
532 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
535 if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
537 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
541 wpa_s, addr,
545 wpa_s->keys_cleared = (u32) -1;
585 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
589 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
590 name = wpa_s->current_ssid->bgscan;
592 name = wpa_s->conf->bgscan;
595 if (wpas_driver_bss_selection(wpa_s))
597 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
600 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
604 bgscan_deinit(wpa_s);
605 if (wpa_s->current_ssid) {
606 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
607 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
616 wpa_s->bgscan_ssid = wpa_s->current_ssid;
617 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
620 bgscan_notify_scan(wpa_s, scan_res);
625 wpa_s->bgscan_ssid = NULL;
629 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
631 if (wpa_s->bgscan_ssid != NULL) {
632 bgscan_deinit(wpa_s);
633 wpa_s->bgscan_ssid = NULL;
640 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
642 if (autoscan_init(wpa_s, 0))
643 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
647 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
649 autoscan_deinit(wpa_s);
653 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
655 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
656 wpa_s->wpa_state == WPA_SCANNING) {
657 autoscan_deinit(wpa_s);
658 wpa_supplicant_start_autoscan(wpa_s);
665 * @wpa_s: Pointer to wpa_supplicant data
671 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
674 enum wpa_states old_state = wpa_s->wpa_state;
676 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
677 wpa_supplicant_state_txt(wpa_s->wpa_state),
682 wpa_s->normal_scans = 0;
686 wpas_connect_work_done(wpa_s);
688 wpa_s->normal_scans = 0;
692 wpa_supplicant_notify_scanning(wpa_s, 0);
694 if (state == WPA_COMPLETED && wpa_s->new_connection) {
695 struct wpa_ssid *ssid = wpa_s->current_ssid;
697 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
699 MAC2STR(wpa_s->bssid),
703 wpas_clear_temp_disabled(wpa_s, ssid, 1);
704 wpa_s->extra_blacklist_count = 0;
705 wpa_s->new_connection = 0;
706 wpa_drv_set_operstate(wpa_s, 1);
708 wpa_drv_set_supp_port(wpa_s, 1);
710 wpa_s->after_wps = 0;
711 wpa_s->known_wps_freq = 0;
712 wpas_p2p_completed(wpa_s);
714 sme_sched_obss_scan(wpa_s, 1);
717 wpa_s->new_connection = 1;
718 wpa_drv_set_operstate(wpa_s, 0);
720 wpa_drv_set_supp_port(wpa_s, 0);
722 sme_sched_obss_scan(wpa_s, 0);
724 wpa_s->wpa_state = state;
728 wpa_supplicant_start_bgscan(wpa_s);
730 wpa_supplicant_stop_bgscan(wpa_s);
734 wpa_supplicant_stop_autoscan(wpa_s);
737 wpa_supplicant_start_autoscan(wpa_s);
739 if (wpa_s->wpa_state != old_state) {
740 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
746 wpas_p2p_indicate_state_change(wpa_s);
748 if (wpa_s->wpa_state == WPA_COMPLETED ||
750 wpas_notify_auth_changed(wpa_s);
759 struct wpa_supplicant *wpa_s = global->ifaces;
760 while (wpa_s) {
761 struct wpa_supplicant *next = wpa_s->next;
762 if (wpas_wps_terminate_pending(wpa_s) == 1)
765 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
766 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
767 wpas_p2p_disconnect(wpa_s);
769 wpa_s = next;
785 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
787 enum wpa_states old_state = wpa_s->wpa_state;
789 wpa_s->pairwise_cipher = 0;
790 wpa_s->group_cipher = 0;
791 wpa_s->mgmt_group_cipher = 0;
792 wpa_s->key_mgmt = 0;
793 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
794 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
796 if (wpa_s->wpa_state != old_state)
797 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
803 * @wpa_s: Pointer to wpa_supplicant data
812 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
818 if (wpa_s->confname == NULL)
820 conf = wpa_config_read(wpa_s->confname, NULL);
822 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
823 "file '%s' - exiting", wpa_s->confname);
826 wpa_config_read(wpa_s->confanother, conf);
830 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
831 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
833 wpa_s->conf->ctrl_interface) != 0);
835 if (reconf_ctrl && wpa_s->ctrl_iface) {
836 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
837 wpa_s->ctrl_iface = NULL;
840 eapol_sm_invalidate_cached_session(wpa_s->eapol);
841 if (wpa_s->current_ssid) {
842 wpa_supplicant_deauthenticate(wpa_s,
850 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
855 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
857 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
858 wpa_sm_set_config(wpa_s->wpa, NULL);
859 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
860 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
861 rsn_preauth_deinit(wpa_s->wpa);
863 old_ap_scan = wpa_s->conf->ap_scan;
864 wpa_config_free(wpa_s->conf);
865 wpa_s->conf = conf;
866 if (old_ap_scan != wpa_s->conf->ap_scan)
867 wpas_notify_ap_scan_changed(wpa_s);
870 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
872 wpa_supplicant_update_config(wpa_s);
874 wpa_supplicant_clear_status(wpa_s);
875 if (wpa_supplicant_enabled_networks(wpa_s)) {
876 wpa_s->reassociate = 1;
877 wpa_supplicant_req_scan(wpa_s, 0, 0);
879 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
887 struct wpa_supplicant *wpa_s;
888 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
889 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
891 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
898 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
902 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
905 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
911 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
914 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
920 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
926 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
935 wpa_s->conf->pmf : ssid->ieee80211w) ==
937 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
950 * @wpa_s: Pointer to wpa_supplicant data
962 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
982 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
989 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
993 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1002 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1011 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1021 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1027 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1032 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1037 wpa_s->wpa_proto = proto;
1038 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1039 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1042 if (bss || !wpa_s->ap_ies_from_associnfo) {
1043 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1045 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1051 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1052 if (wpa_s->group_cipher < 0) {
1053 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1057 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1058 wpa_cipher_txt(wpa_s->group_cipher));
1061 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1062 if (wpa_s->pairwise_cipher < 0) {
1063 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1067 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1068 wpa_cipher_txt(wpa_s->pairwise_cipher));
1072 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1078 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1079 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1081 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1082 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1086 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1087 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1089 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1090 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1094 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1095 wpa_dbg(wpa_s, MSG_DEBUG,
1098 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1099 wpa_dbg(wpa_s, MSG_DEBUG,
1103 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1104 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1106 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1107 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1109 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1110 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1113 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1114 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1117 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1122 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1123 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1124 wpa_s->pairwise_cipher);
1125 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1130 wpa_s->conf->pmf : ssid->ieee80211w) == NO_MGMT_FRAME_PROTECTION ||
1134 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1135 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1138 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1139 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1142 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1143 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1146 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1147 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1150 wpa_s->mgmt_group_cipher = 0;
1151 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1153 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1154 wpa_s->mgmt_group_cipher);
1155 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1157 wpa_s->conf->pmf : ssid->ieee80211w));
1160 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1161 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1166 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
1175 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1180 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1186 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1192 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1211 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1216 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1222 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1224 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1236 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1242 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1262 if (wpa_s->conf->interworking)
1268 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1274 if (wpa_s->conf->hs20)
1284 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1289 if (len < wpa_s->extended_capa_len)
1290 len = wpa_s->extended_capa_len;
1300 wpas_ext_capab_byte(wpa_s, pos, i);
1302 if (i < wpa_s->extended_capa_len) {
1303 *pos &= ~wpa_s->extended_capa_mask[i];
1304 *pos |= wpa_s->extended_capa[i];
1319 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1324 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1333 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1338 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1347 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1350 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1353 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1365 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1368 struct wpa_radio_work *work = wpa_s->connect_work;
1373 wpa_s->connect_work = NULL;
1381 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1387 if (wpa_s->last_mac_addr_style == style &&
1388 wpa_s->last_mac_addr_change.sec != 0 &&
1389 !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1390 wpa_s->conf->rand_addr_lifetime)) {
1391 wpa_msg(wpa_s, MSG_DEBUG,
1402 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1410 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1411 wpa_msg(wpa_s, MSG_INFO,
1416 os_get_reltime(&wpa_s->last_mac_addr_change);
1417 wpa_s->mac_addr_changed = 1;
1418 wpa_s->last_mac_addr_style = style;
1420 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1421 wpa_msg(wpa_s, MSG_INFO,
1426 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1433 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1435 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1436 !wpa_s->conf->preassoc_mac_addr)
1439 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1447 * @wpa_s: Pointer to wpa_supplicant data
1453 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1460 rand_style = wpa_s->conf->mac_addr;
1464 if (wpa_s->last_ssid == ssid) {
1465 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1467 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1469 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1470 } else if (wpa_s->mac_addr_changed) {
1471 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1472 wpa_msg(wpa_s, MSG_INFO,
1476 wpa_s->mac_addr_changed = 0;
1477 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1478 wpa_msg(wpa_s, MSG_INFO,
1482 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1484 wpa_s->last_ssid = ssid;
1487 ibss_rsn_deinit(wpa_s->ibss_rsn);
1488 wpa_s->ibss_rsn = NULL;
1494 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1495 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1499 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1500 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1502 wpas_p2p_ap_setup_failed(wpa_s);
1505 wpa_s->current_bss = bss;
1507 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1515 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1519 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1521 sme_authenticate(wpa_s, bss, ssid);
1525 if (wpa_s->connect_work) {
1526 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1530 if (radio_work_pending(wpa_s, "connect")) {
1531 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1542 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1554 struct wpa_supplicant *wpa_s = work->wpa_s;
1575 wpa_s->connect_work = NULL;
1578 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
1585 wpa_s->connect_work = work;
1587 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid)) {
1588 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
1589 wpas_connect_work_done(wpa_s);
1594 wpa_s->reassociate = 0;
1595 wpa_s->eap_expected_failure = 0;
1596 if (bss && !wpas_driver_bss_selection(wpa_s)) {
1600 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1603 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1604 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1605 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1607 wpas_notify_bssid_changed(wpa_s);
1612 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1615 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1620 wpa_s->conf->ap_scan == 2 &&
1624 wpas_connect_work_done(wpa_s);
1625 wpa_s->scan_req = MANUAL_SCAN_REQ;
1626 wpa_s->reassociate = 1;
1627 wpa_supplicant_req_scan(wpa_s, 0, 0);
1631 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1633 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1635 wpa_supplicant_cancel_sched_scan(wpa_s);
1636 wpa_supplicant_cancel_scan(wpa_s);
1640 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1652 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1655 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1664 wpa_s->conf->okc :
1667 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1669 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1671 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1673 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1675 wpas_connect_work_done(wpa_s);
1685 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1687 wpa_s->wpa_proto = 0;
1690 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1692 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1695 wpas_connect_work_done(wpa_s);
1708 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1713 wpa_s->wpa_proto = 0;
1716 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1718 wpa_s->wpa_proto = 0;
1722 if (wpa_s->global->p2p) {
1728 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1734 wpa_s->cross_connect_disallowed = 0;
1739 wpa_s->cross_connect_disallowed =
1742 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1744 wpa_s->cross_connect_disallowed ?
1749 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
1753 if (is_hs20_network(wpa_s, ssid, bss)) {
1757 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
1783 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
1796 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1798 cipher_pairwise = wpa_s->pairwise_cipher;
1799 cipher_group = wpa_s->group_cipher;
1800 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1801 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1802 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1804 if (wpa_set_wep_keys(wpa_s, ssid)) {
1809 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1813 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1828 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1830 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1833 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1837 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1854 wpa_s->conf->ap_scan == 2) {
1867 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1868 if (wpa_s->hw.modes[i].mode == hw_mode) {
1871 mode = &wpa_s->hw.modes[i];
1882 params.beacon_int = wpa_s->conf->beacon_int;
1889 params.key_mgmt_suite = wpa_s->key_mgmt;
1890 params.wpa_proto = wpa_s->wpa_proto;
1901 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1914 wpa_s->conf->pmf : ssid->ieee80211w;
1921 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1931 if (wpa_s->parent->set_sta_uapsd)
1932 params.uapsd = wpa_s->parent->sta_uapsd;
1941 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
1948 wpa_supplicant_apply_vht_overrides(wpa_s, wpa_s->current_ssid, ¶ms);
1957 if (wpa_s->num_multichan_concurrent < 2) {
1959 num = get_shared_radio_freqs(wpa_s, &freq, 1);
1965 wpa_s, params.freq.freq, ssid) < 0) {
1966 wpas_connect_work_done(wpa_s);
1973 ret = wpa_drv_associate(wpa_s, ¶ms);
1975 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1977 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1983 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
1984 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1985 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1993 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1996 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1999 wpa_supplicant_cancel_auth_timeout(wpa_s);
2000 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2003 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2004 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2009 wpa_supplicant_cancel_auth_timeout(wpa_s);
2018 } else if (wpa_s->conf->ap_scan == 1) {
2022 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2026 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2028 wpa_set_wep_keys(wpa_s, ssid);
2031 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2036 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2038 old_ssid = wpa_s->current_ssid;
2039 wpa_s->current_ssid = ssid;
2040 wpa_s->current_bss = bss;
2041 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2042 wpa_supplicant_initiate_eapol(wpa_s);
2043 if (old_ssid != wpa_s->current_ssid)
2044 wpas_notify_network_changed(wpa_s);
2048 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2053 wpa_clear_keys(wpa_s, addr);
2054 old_ssid = wpa_s->current_ssid;
2055 wpa_supplicant_mark_disassoc(wpa_s);
2056 wpa_sm_set_config(wpa_s->wpa, NULL);
2057 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2058 if (old_ssid != wpa_s->current_ssid)
2059 wpas_notify_network_changed(wpa_s);
2060 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2066 * @wpa_s: Pointer to wpa_supplicant data
2072 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2079 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2081 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2082 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2084 if (!is_zero_ether_addr(wpa_s->bssid))
2085 addr = wpa_s->bssid;
2086 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2087 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2088 wpa_s->wpa_state == WPA_ASSOCIATING))
2089 addr = wpa_s->pending_bssid;
2090 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2097 addr = wpa_s->bssid;
2102 wpa_tdls_teardown_peers(wpa_s->wpa);
2106 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2110 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2115 wpa_supplicant_clear_connection(wpa_s, addr);
2118 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2125 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2126 wpas_notify_network_enabled_changed(wpa_s, ssid);
2132 if (!wpa_s->current_ssid && !wpa_s->disconnected)
2133 wpa_s->reassociate = 1;
2139 * @wpa_s: wpa_supplicant structure for a network interface
2144 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2148 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2149 wpa_supplicant_enable_one_network(wpa_s, ssid);
2151 wpa_supplicant_enable_one_network(wpa_s, ssid);
2153 if (wpa_s->reassociate && !wpa_s->disconnected) {
2154 if (wpa_s->sched_scanning) {
2157 wpa_supplicant_cancel_sched_scan(wpa_s);
2160 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2161 wpa_supplicant_req_scan(wpa_s, 0, 0);
2168 * @wpa_s: wpa_supplicant structure for a network interface
2173 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2180 if (wpa_s->sched_scanning)
2181 wpa_supplicant_cancel_sched_scan(wpa_s);
2183 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2194 wpa_s, other_ssid);
2196 if (wpa_s->current_ssid)
2198 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2200 if (ssid == wpa_s->current_ssid)
2202 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2209 wpas_notify_network_enabled_changed(wpa_s, ssid);
2210 if (wpa_s->sched_scanning) {
2213 wpa_supplicant_cancel_sched_scan(wpa_s);
2214 wpa_supplicant_req_scan(wpa_s, 0, 0);
2223 * @wpa_s: wpa_supplicant structure for a network interface
2226 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2233 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2235 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2240 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2246 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2254 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2257 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2260 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
2268 wpa_s->current_ssid = ssid;
2269 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2271 wpa_s->connect_without_scan = NULL;
2272 wpa_s->disconnected = 0;
2273 wpa_s->reassociate = 1;
2275 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2276 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
2279 wpas_notify_network_selected(wpa_s, ssid);
2285 * @wpa_s: wpa_supplicant structure for a network interface
2294 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
2314 os_free(wpa_s->conf->pkcs11_engine_path);
2315 os_free(wpa_s->conf->pkcs11_module_path);
2316 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2317 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2319 wpa_sm_set_eapol(wpa_s->wpa, NULL);
2320 eapol_sm_deinit(wpa_s->eapol);
2321 wpa_s->eapol = NULL;
2322 if (wpa_supplicant_init_eapol(wpa_s)) {
2325 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2330 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2338 * @wpa_s: wpa_supplicant structure for a network interface
2343 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
2352 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2353 wpa_s->wpa_state >= WPA_ASSOCIATING &&
2354 wpa_s->wpa_state < WPA_COMPLETED) {
2356 "associating", wpa_s->conf->ap_scan, ap_scan);
2361 old_ap_scan = wpa_s->conf->ap_scan;
2362 wpa_s->conf->ap_scan = ap_scan;
2364 if (old_ap_scan != wpa_s->conf->ap_scan)
2365 wpas_notify_ap_scan_changed(wpa_s);
2373 * @wpa_s: wpa_supplicant structure for a network interface
2378 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2382 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2386 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2388 wpa_s->conf->bss_expiration_age = bss_expire_age;
2396 * @wpa_s: wpa_supplicant structure for a network interface
2401 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2405 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2409 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2411 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2419 * @wpa_s: wpa_supplicant structure for a network interface
2424 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2428 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2432 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2434 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
2484 * @wpa_s: Pointer to wpa_supplicant data
2487 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2496 res = wpa_drv_get_ssid(wpa_s, ssid);
2498 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2504 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2505 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2510 wired = wpa_s->conf->ap_scan == 0 &&
2511 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2513 entry = wpa_s->conf->ssid;
2515 if (!wpas_network_disabled(wpa_s, entry) &&
2522 if (!wpas_network_disabled(wpa_s, entry) &&
2530 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2542 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2544 struct wpa_global *global = wpa_s->global;
2555 wpa_s->driver = wpa_drivers[i];
2556 wpa_s->global_drv_priv = global->drv_priv[i];
2562 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2569 if (wpa_s == NULL)
2573 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2580 return select_driver(wpa_s, 0);
2595 if (select_driver(wpa_s, i) == 0)
2603 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2610 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2625 struct wpa_supplicant *wpa_s = ctx;
2627 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2631 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
2632 wpa_s->current_ssid->peerkey &&
2633 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2634 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
2635 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
2640 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2641 (wpa_s->last_eapol_matches_bssid &&
2643 !wpa_s->ap_iface &&
2645 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
2658 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
2660 wpa_supplicant_state_txt(wpa_s->wpa_state),
2661 MAC2STR(wpa_s->bssid));
2662 wpabuf_free(wpa_s->pending_eapol_rx);
2663 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2664 if (wpa_s->pending_eapol_rx) {
2665 os_get_reltime(&wpa_s->pending_eapol_rx_time);
2666 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2672 wpa_s->last_eapol_matches_bssid =
2673 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2676 if (wpa_s->ap_iface) {
2677 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2682 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2683 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2688 if (wpa_s->eapol_received == 0 &&
2689 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2690 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2691 wpa_s->wpa_state != WPA_COMPLETED) &&
2692 (wpa_s->current_ssid == NULL ||
2693 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2696 wpa_s,
2697 (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2698 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2699 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2702 wpa_s->eapol_received++;
2704 if (wpa_s->countermeasures) {
2705 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2711 if (wpa_s->current_ssid &&
2712 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2713 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2724 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2725 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2726 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2728 wpa_drv_poll(wpa_s);
2729 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2730 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2731 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2738 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2743 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
2745 if (wpa_s->driver->send_eapol) {
2746 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2748 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2749 } else if ((!wpa_s->p2p_mgmt ||
2750 !(wpa_s->drv_flags &
2752 !(wpa_s->drv_flags &
2754 l2_packet_deinit(wpa_s->l2);
2755 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2756 wpa_drv_get_mac_addr(wpa_s),
2758 wpa_supplicant_rx_eapol, wpa_s, 0);
2759 if (wpa_s->l2 == NULL)
2762 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2764 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2767 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2768 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2772 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2781 struct wpa_supplicant *wpa_s = ctx;
2788 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2790 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2796 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2798 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2805 * @wpa_s: Pointer to wpa_supplicant data
2812 wpa_s)
2816 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2819 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2820 MAC2STR(wpa_s->own_addr));
2821 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
2822 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2824 if (wpa_s->bridge_ifname[0]) {
2825 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2826 "interface '%s'", wpa_s->bridge_ifname);
2827 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2828 wpa_s->own_addr,
2831 wpa_s, 1);
2832 if (wpa_s->l2_br == NULL) {
2833 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2835 wpa_s->bridge_ifname);
2840 wpa_clear_keys(wpa_s, NULL);
2844 wpa_drv_set_countermeasures(wpa_s, 0);
2846 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2847 wpa_drv_flush_pmkid(wpa_s);
2849 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2850 wpa_s->prev_scan_wildcard = 0;
2852 if (wpa_supplicant_enabled_networks(wpa_s)) {
2853 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
2854 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2857 if (!wpa_s->p2p_mgmt &&
2858 wpa_supplicant_delayed_sched_scan(wpa_s,
2861 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
2865 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2880 struct wpa_supplicant *wpa_s;
2882 wpa_s = os_zalloc(sizeof(*wpa_s));
2883 if (wpa_s == NULL)
2885 wpa_s->scan_req = INITIAL_SCAN_REQ;
2886 wpa_s->scan_interval = 5;
2887 wpa_s->new_connection = 1;
2888 wpa_s->parent = wpa_s;
2889 wpa_s->sched_scanning = 0;
2891 return wpa_s;
2897 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2914 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2920 wpa_msg(wpa_s, MSG_DEBUG,
2929 wpa_msg(wpa_s, MSG_ERROR,
2951 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2958 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2974 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
2979 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
2985 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
2998 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3003 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3009 wpa_msg(wpa_s, MSG_ERROR,
3023 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3032 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3045 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3054 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3067 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3075 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3089 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3104 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3105 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3107 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3108 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3109 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3110 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3111 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3125 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3156 wpa_set_ampdu_factor(wpa_s,
3189 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3194 if (!wpa_s->conf->pcsc_reader)
3197 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3198 if (!wpa_s->scard)
3201 if (wpa_s->conf->pcsc_pin &&
3202 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3203 scard_deinit(wpa_s->scard);
3204 wpa_s->scard = NULL;
3205 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3209 len = sizeof(wpa_s->imsi) - 1;
3210 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3211 scard_deinit(wpa_s->scard);
3212 wpa_s->scard = NULL;
3213 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3216 wpa_s->imsi[len] = '\0';
3218 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3221 wpa_s->imsi, wpa_s->mnc_len);
3223 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3224 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3231 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3235 ext_password_deinit(wpa_s->ext_pw);
3236 wpa_s->ext_pw = NULL;
3237 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3239 if (!wpa_s->conf->ext_password_backend)
3242 val = os_strdup(wpa_s->conf->ext_password_backend);
3251 wpa_s->ext_pw = ext_password_init(val, pos);
3253 if (wpa_s->ext_pw == NULL) {
3257 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3263 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
3269 if (!wpa_s->conf->wowlan_triggers)
3272 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
3274 ret = wpa_drv_wowlan(wpa_s, triggers);
3281 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
3284 struct wpa_supplicant *iface = wpa_s->global->ifaces;
3291 wpa_s->ifname, rn);
3292 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3300 wpa_s->ifname, rn ? rn : "N/A");
3309 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3317 if (work->wpa_s->scan_work == work) {
3319 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
3321 work->wpa_s->scan_work = NULL;
3325 if (work->wpa_s->p2p_scan_work == work) {
3327 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
3329 work->wpa_s->p2p_scan_work = NULL;
3343 struct wpa_supplicant *wpa_s;
3352 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
3354 if (wpa_s && wpa_s->external_scan_running) {
3361 wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting radio work '%s'@%p after %ld.%06ld second wait",
3375 * @wpa_s: wpa_supplicant data
3380 void radio_remove_works(struct wpa_supplicant *wpa_s,
3384 struct wpa_radio *radio = wpa_s->radio;
3392 if (!remove_all && work->wpa_s != wpa_s)
3395 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
3402 radio_work_check_next(wpa_s);
3406 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
3408 struct wpa_radio *radio = wpa_s->radio;
3414 wpa_s->ifname, radio->name);
3415 dl_list_del(&wpa_s->radio_list);
3416 radio_remove_works(wpa_s, NULL, 0);
3417 wpa_s->radio = NULL;
3427 void radio_work_check_next(struct wpa_supplicant *wpa_s)
3429 struct wpa_radio *radio = wpa_s->radio;
3440 * @wpa_s: Pointer to wpa_supplicant data
3463 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
3474 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
3478 work->wpa_s = wpa_s;
3482 was_empty = dl_list_empty(&wpa_s->radio->work);
3484 dl_list_add(&wpa_s->radio->work, &work->list);
3486 dl_list_add_tail(&wpa_s->radio->work, &work->list);
3488 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
3489 radio_work_check_next(wpa_s);
3505 struct wpa_supplicant *wpa_s = work->wpa_s;
3511 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
3516 radio_work_check_next(wpa_s);
3521 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
3524 struct wpa_radio *radio = wpa_s->radio;
3527 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
3535 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
3542 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
3545 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
3546 if (wpa_s->drv_priv == NULL) {
3550 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
3555 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
3559 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
3560 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
3561 "driver_param '%s'", wpa_s->conf->driver_param);
3565 ifname = wpa_drv_get_ifname(wpa_s);
3566 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
3567 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
3569 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
3572 rn = wpa_driver_get_radio_name(wpa_s);
3576 wpa_s->radio = radio_add_interface(wpa_s, rn);
3577 if (wpa_s->radio == NULL)
3584 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
3598 wpa_s->confname = os_rel2abs_path(iface->confname);
3599 if (wpa_s->confname == NULL) {
3606 iface->confname, wpa_s->confname);
3608 wpa_s->confname = os_strdup(iface->confname);
3610 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
3611 if (wpa_s->conf == NULL) {
3613 "configuration '%s'.", wpa_s->confname);
3616 wpa_s->confanother = os_rel2abs_path(iface->confanother);
3617 wpa_config_read(wpa_s->confanother, wpa_s->conf);
3624 os_free(wpa_s->conf->ctrl_interface);
3625 wpa_s->conf->ctrl_interface =
3630 os_free(wpa_s->conf->driver_param);
3631 wpa_s->conf->driver_param =
3636 os_free(wpa_s->conf->ctrl_interface);
3637 wpa_s->conf->ctrl_interface = NULL;
3640 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
3643 if (wpa_s->conf == NULL) {
3652 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
3657 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
3661 sizeof(wpa_s->bridge_ifname)) {
3666 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
3667 sizeof(wpa_s->bridge_ifname));
3671 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
3672 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
3678 if (wpas_init_driver(wpa_s, iface) < 0)
3681 if (wpa_supplicant_init_wpa(wpa_s) < 0)
3684 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
3685 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
3687 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
3689 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
3690 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
3691 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
3692 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3697 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
3698 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
3699 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
3700 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3705 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
3706 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
3707 wpa_s->conf->dot11RSNAConfigSATimeout)) {
3708 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3713 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
3714 &wpa_s->hw.num_modes,
3715 &wpa_s->hw.flags);
3717 if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
3718 wpa_s->drv_capa_known = 1;
3719 wpa_s->drv_flags = capa.flags;
3720 wpa_s->drv_enc = capa.enc;
3721 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
3722 wpa_s->max_scan_ssids = capa.max_scan_ssids;
3723 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
3724 wpa_s->sched_scan_supported = capa.sched_scan_supported;
3725 wpa_s->max_match_sets = capa.max_match_sets;
3726 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
3727 wpa_s->max_stations = capa.max_stations;
3728 wpa_s->extended_capa = capa.extended_capa;
3729 wpa_s->extended_capa_mask = capa.extended_capa_mask;
3730 wpa_s->extended_capa_len = capa.extended_capa_len;
3731 wpa_s->num_multichan_concurrent =
3734 if (wpa_s->max_remain_on_chan == 0)
3735 wpa_s->max_remain_on_chan = 1000;
3742 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
3743 wpa_s->p2p_mgmt = iface->p2p_mgmt;
3747 if (wpa_s->num_multichan_concurrent == 0)
3748 wpa_s->num_multichan_concurrent = 1;
3750 if (wpa_supplicant_driver_init(wpa_s) < 0)
3755 !(wpa_s->drv_flags &
3757 wpa_tdls_init(wpa_s->wpa))
3761 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3762 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
3763 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
3767 if (wpas_wps_init(wpa_s))
3770 if (wpa_supplicant_init_eapol(wpa_s) < 0)
3772 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3774 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3775 if (wpa_s->ctrl_iface == NULL) {
3784 wpa_s->conf->ctrl_interface);
3788 wpa_s->gas = gas_query_init(wpa_s);
3789 if (wpa_s->gas == NULL) {
3794 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
3795 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
3799 if (wpa_bss_init(wpa_s) < 0)
3807 if (wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
3813 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
3815 if (wpa_s->mnc_len > 0) {
3816 wpa_s->imsi[len] = '\0';
3818 wpa_s->imsi, wpa_s->mnc_len);
3825 if (pcsc_reader_init(wpa_s) < 0)
3828 if (wpas_init_ext_pw(wpa_s) < 0)
3835 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
3838 wpa_s->disconnected = 1;
3839 if (wpa_s->drv_priv) {
3840 wpa_supplicant_deauthenticate(wpa_s,
3843 wpa_drv_set_countermeasures(wpa_s, 0);
3844 wpa_clear_keys(wpa_s, NULL);
3847 wpa_supplicant_cleanup(wpa_s);
3848 wpas_p2p_deinit_iface(wpa_s);
3850 wpas_ctrl_radio_work_flush(wpa_s);
3851 radio_remove_interface(wpa_s);
3853 if (wpa_s->drv_priv)
3854 wpa_drv_deinit(wpa_s);
3857 wpas_notify_iface_removed(wpa_s);
3860 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
3862 if (wpa_s->ctrl_iface) {
3863 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3864 wpa_s->ctrl_iface = NULL;
3867 if (wpa_s->conf != NULL) {
3868 wpa_config_free(wpa_s->conf);
3869 wpa_s->conf = NULL;
3872 os_free(wpa_s);
3891 struct wpa_supplicant *wpa_s;
3898 wpa_s = wpa_supplicant_alloc();
3899 if (wpa_s == NULL)
3902 wpa_s->global = global;
3919 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
3922 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
3927 if (wpas_notify_iface_added(wpa_s)) {
3928 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
3932 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3933 wpas_notify_network_added(wpa_s, ssid);
3935 wpa_s->next = global->ifaces;
3936 global->ifaces = wpa_s;
3938 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
3939 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3941 return wpa_s;
3948 * @wpa_s: Pointer to the network interface to be removed
3957 struct wpa_supplicant *wpa_s,
3964 if (prev == wpa_s) {
3965 global->ifaces = wpa_s->next;
3967 while (prev && prev->next != wpa_s)
3971 prev->next = wpa_s->next;
3974 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3976 if (global->p2p_group_formation == wpa_s)
3978 if (global->p2p_invite_group == wpa_s)
3980 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
3988 * @wpa_s: Pointer to the network interface
3991 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3995 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3996 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
4000 wpa_s->eapol);
4017 struct wpa_supplicant *wpa_s;
4019 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4020 if (os_strcmp(wpa_s->ifname, ifname) == 0)
4021 return wpa_s;
4030 struct wpa_supplicant *wpa_s = ctx;
4031 if (wpa_s == NULL)
4033 return wpa_s->ifname;
4173 struct wpa_supplicant *wpa_s;
4180 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
4181 if (wpa_s->ctrl_iface)
4183 wpa_s->ctrl_iface);
4257 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
4259 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
4260 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
4262 country[0] = wpa_s->conf->country[0];
4263 country[1] = wpa_s->conf->country[1];
4265 if (wpa_drv_set_country(wpa_s, country) < 0) {
4271 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
4272 wpas_init_ext_pw(wpa_s);
4275 wpas_wps_update_config(wpa_s);
4277 wpas_p2p_update_config(wpa_s);
4278 wpa_s->conf->changed_parameters = 0;
4296 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
4307 cbss = wpa_s->current_bss;
4309 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
4314 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
4330 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
4336 wpas_connect_work_done(wpa_s);
4341 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
4343 if (wpa_s->disconnected) {
4348 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
4362 count = wpa_blacklist_add(wpa_s, bssid);
4363 if (count == 1 && wpa_s->current_bss) {
4370 freqs = get_bss_freqs_in_ess(wpa_s);
4372 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
4374 wpa_blacklist_add(wpa_s, bssid);
4380 os_free(wpa_s->next_scan_freqs);
4381 wpa_s->next_scan_freqs = freqs;
4389 count += wpa_s->extra_blacklist_count;
4391 if (count > 3 && wpa_s->current_ssid) {
4394 wpas_auth_failed(wpa_s, "CONN_FAILED");
4415 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
4422 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
4427 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
4429 return wpa_s->conf->ap_scan == 2 ||
4430 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
4435 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
4453 if (ssid == wpa_s->current_ssid)
4454 wpa_s->reassociate = 1;
4461 if (ssid == wpa_s->current_ssid)
4462 wpa_s->reassociate = 1;
4469 if (ssid == wpa_s->current_ssid)
4470 wpa_s->reassociate = 1;
4476 if (ssid == wpa_s->current_ssid)
4477 wpa_s->reassociate = 1;
4491 if (ssid == wpa_s->current_ssid)
4492 wpa_s->reassociate = 1;
4512 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
4523 if (wpa_s && wpa_s->drv_capa_known)
4524 drv_enc = wpa_s->drv_enc;
4549 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
4551 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
4553 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
4559 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
4561 struct wpa_ssid *ssid = wpa_s->current_ssid;
4578 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
4612 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
4619 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
4626 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
4637 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
4641 if (wpa_s->disallow_aps_bssid == NULL)
4644 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
4645 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
4654 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
4659 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
4662 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
4663 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
4675 * @wpa_s: Pointer to the network interface
4681 void wpas_request_connection(struct wpa_supplicant *wpa_s)
4683 wpa_s->normal_scans = 0;
4684 wpa_supplicant_reinit_autoscan(wpa_s);
4685 wpa_s->extra_blacklist_count = 0;
4686 wpa_s->disconnected = 0;
4687 wpa_s->reassociate = 1;
4689 if (wpa_supplicant_fast_associate(wpa_s) != 1)
4690 wpa_supplicant_req_scan(wpa_s, 0, 0);
4694 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
4700 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
4704 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
4715 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
4724 wpa_dbg(wpa_s, MSG_DEBUG,
4728 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
4759 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
4768 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
4780 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
