Lines Matching refs:wpa_s
28 static void wpa_supplicant_gen_assoc_event(struct wpa_supplicant *wpa_s)
33 ssid = wpa_supplicant_get_ssid(wpa_s);
37 if (wpa_s->current_ssid == NULL) {
38 wpa_s->current_ssid = ssid;
39 if (wpa_s->current_ssid != NULL)
40 wpas_notify_network_changed(wpa_s);
42 wpa_supplicant_initiate_eapol(wpa_s);
43 wpa_dbg(wpa_s, MSG_DEBUG, "Already associated with a configured "
46 wpa_supplicant_event(wpa_s, EVENT_ASSOC, &data);
51 static int wpas_wps_in_use(struct wpa_supplicant *wpa_s,
57 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
71 if (!wpa_s->global->p2p_disabled && wpa_s->global->p2p &&
72 !wpa_s->conf->p2p_disabled) {
73 wpa_s->wps->dev.p2p = 1;
88 * @wpa_s: Pointer to wpa_supplicant data
95 int wpa_supplicant_enabled_networks(struct wpa_supplicant *wpa_s)
97 struct wpa_ssid *ssid = wpa_s->conf->ssid;
100 if (wpa_s->p2p_mgmt)
104 if (!wpas_network_disabled(wpa_s, ssid))
110 if (wpa_s->conf->cred && wpa_s->conf->interworking &&
111 wpa_s->conf->auto_interworking)
114 wpa_dbg(wpa_s, MSG_DEBUG, "No enabled networks (%d disabled "
121 static void wpa_supplicant_assoc_try(struct wpa_supplicant *wpa_s,
125 if (!wpas_network_disabled(wpa_s, ssid))
132 wpa_dbg(wpa_s, MSG_DEBUG, "wpa_supplicant_assoc_try: Reached "
134 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
135 wpa_supplicant_req_scan(wpa_s, 0, 0);
140 wpa_s->prev_scan_ssid = ssid;
143 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
145 wpa_supplicant_associate(wpa_s, NULL, ssid);
151 struct wpa_supplicant *wpa_s = work->wpa_s;
160 wpa_supplicant_notify_scanning(wpa_s, 0);
161 wpas_notify_scan_done(wpa_s, 0);
162 wpa_s->scan_work = NULL;
166 if (wpas_update_random_addr_disassoc(wpa_s) < 0) {
167 wpa_msg(wpa_s, MSG_INFO,
173 wpa_supplicant_notify_scanning(wpa_s, 1);
175 if (wpa_s->clear_driver_scan_cache) {
180 ret = wpa_drv_scan(wpa_s, params);
184 int retry = wpa_s->last_scan_req != MANUAL_SCAN_REQ;
186 if (wpa_s->disconnected)
189 wpa_supplicant_notify_scanning(wpa_s, 0);
190 wpas_notify_scan_done(wpa_s, 0);
191 if (wpa_s->wpa_state == WPA_SCANNING)
192 wpa_supplicant_set_state(wpa_s,
193 wpa_s->scan_prev_wpa_state);
194 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SCAN_FAILED "ret=%d%s",
200 wpa_s->scan_req = wpa_s->last_scan_req;
201 wpa_supplicant_req_scan(wpa_s, 1, 0);
206 os_get_reltime(&wpa_s->scan_trigger_time);
207 wpa_s->scan_runs++;
208 wpa_s->normal_scans++;
209 wpa_s->own_scan_requested = 1;
210 wpa_s->clear_driver_scan_cache = 0;
211 wpa_s->scan_work = work;
217 * @wpa_s: Pointer to wpa_supplicant data
221 int wpa_supplicant_trigger_scan(struct wpa_supplicant *wpa_s,
226 if (wpa_s->scan_work) {
227 wpa_dbg(wpa_s, MSG_INFO, "Reject scan trigger since one is already pending");
235 if (radio_add_work(wpa_s, 0, "scan", 0, wpas_trigger_scan_cb, ctx) < 0)
248 struct wpa_supplicant *wpa_s = eloop_ctx;
250 wpa_dbg(wpa_s, MSG_DEBUG, "Starting delayed sched scan");
252 if (wpa_supplicant_req_sched_scan(wpa_s))
253 wpa_supplicant_req_scan(wpa_s, 0, 0);
260 struct wpa_supplicant *wpa_s = eloop_ctx;
262 wpa_dbg(wpa_s, MSG_DEBUG, "Sched scan timeout - stopping it");
264 wpa_s->sched_scan_timed_out = 1;
265 wpa_supplicant_cancel_sched_scan(wpa_s);
269 int wpa_supplicant_start_sched_scan(struct wpa_supplicant *wpa_s,
275 wpa_supplicant_notify_scanning(wpa_s, 1);
276 ret = wpa_drv_sched_scan(wpa_s, params, interval * 1000);
278 wpa_supplicant_notify_scanning(wpa_s, 0);
280 wpa_s->sched_scanning = 1;
286 int wpa_supplicant_stop_sched_scan(struct wpa_supplicant *wpa_s)
290 ret = wpa_drv_stop_sched_scan(wpa_s);
292 wpa_dbg(wpa_s, MSG_DEBUG, "stopping sched_scan failed!");
335 struct wpa_supplicant *wpa_s, struct wpa_driver_scan_params *params)
338 if (params->freqs == NULL && wpa_s->p2p_in_provisioning &&
339 wpa_s->go_params) {
341 if (wpa_s->p2p_in_provisioning < 5 &&
342 wpa_s->go_params->freq > 0) {
343 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Scan only GO "
345 wpa_s->go_params->freq);
348 params->freqs[0] = wpa_s->go_params->freq;
349 } else if (wpa_s->p2p_in_provisioning < 8 &&
350 wpa_s->go_params->freq_list[0]) {
351 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Scan only common "
354 wpa_s->go_params->freq_list);
358 wpa_s->p2p_in_provisioning++;
361 if (params->freqs == NULL && wpa_s->p2p_in_invitation) {
366 if (wpa_s->p2p_in_invitation < 5 &&
367 wpa_s->p2p_invite_go_freq > 0) {
368 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Scan only GO preferred frequency %d MHz during invitation",
369 wpa_s->p2p_invite_go_freq);
372 params->freqs[0] = wpa_s->p2p_invite_go_freq;
374 wpa_s->p2p_in_invitation++;
375 if (wpa_s->p2p_in_invitation > 20) {
382 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Clear p2p_in_invitation");
383 wpa_s->p2p_in_invitation = 0;
389 if (params->freqs == NULL && wpa_s->after_wps && wpa_s->wps_freq) {
394 wpa_dbg(wpa_s, MSG_DEBUG, "WPS: Scan only frequency %u MHz "
395 "that was used during provisioning", wpa_s->wps_freq);
398 params->freqs[0] = wpa_s->wps_freq;
399 wpa_s->after_wps--;
400 } else if (wpa_s->after_wps)
401 wpa_s->after_wps--;
403 if (params->freqs == NULL && wpa_s->known_wps_freq && wpa_s->wps_freq)
406 wpa_dbg(wpa_s, MSG_DEBUG, "WPS: Scan only frequency %u MHz",
407 wpa_s->wps_freq);
410 params->freqs[0] = wpa_s->wps_freq;
411 wpa_s->known_wps_freq = 0; /* only do this once */
418 static void wpas_add_interworking_elements(struct wpa_supplicant *wpa_s,
422 wpabuf_put_u8(buf, is_zero_ether_addr(wpa_s->conf->hessid) ? 1 :
424 wpabuf_put_u8(buf, wpa_s->conf->access_network_type);
426 if (!is_zero_ether_addr(wpa_s->conf->hessid))
427 wpabuf_put_data(buf, wpa_s->conf->hessid, ETH_ALEN);
432 static struct wpabuf * wpa_supplicant_extra_ies(struct wpa_supplicant *wpa_s)
442 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
449 if (wpa_s->conf->interworking &&
451 wpas_add_interworking_elements(wpa_s, extra_ie);
455 wps = wpas_wps_in_use(wpa_s, &req_type);
461 &wpa_s->wps->dev,
462 wpa_s->wps->uuid, req_type,
473 size_t ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
475 wpas_p2p_scan_ie(wpa_s, extra_ie);
479 wpa_supplicant_mesh_add_scan_ie(wpa_s, &extra_ie);
484 if (wpa_s->conf->hs20 && wpabuf_resize(&extra_ie, 7) == 0)
498 static int non_p2p_network_enabled(struct wpa_supplicant *wpa_s)
502 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
503 if (wpas_network_disabled(wpa_s, ssid))
509 if (wpa_s->conf->cred && wpa_s->conf->interworking &&
510 wpa_s->conf->auto_interworking)
534 static void wpa_setband_scan_freqs_list(struct wpa_supplicant *wpa_s,
542 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, band);
560 static void wpa_setband_scan_freqs(struct wpa_supplicant *wpa_s,
563 if (wpa_s->hw.modes == NULL)
567 if (wpa_s->setband == WPA_SETBAND_5G)
568 wpa_setband_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211A,
570 else if (wpa_s->setband == WPA_SETBAND_2G)
571 wpa_setband_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211G,
576 static void wpa_set_scan_ssids(struct wpa_supplicant *wpa_s,
583 for (i = 0; i < wpa_s->scan_id_count; i++) {
586 ssid = wpa_config_get_network(wpa_s->conf, wpa_s->scan_id[i]);
613 wpa_s->scan_id_count = 0;
617 static int wpa_set_ssids_from_scan_req(struct wpa_supplicant *wpa_s,
623 if (wpa_s->ssids_from_scan_req == NULL ||
624 wpa_s->num_ssids_from_scan_req == 0)
627 if (wpa_s->num_ssids_from_scan_req > max_ssids) {
628 wpa_s->num_ssids_from_scan_req = max_ssids;
633 for (i = 0; i < wpa_s->num_ssids_from_scan_req; i++) {
634 params->ssids[i].ssid = wpa_s->ssids_from_scan_req[i].ssid;
636 wpa_s->ssids_from_scan_req[i].ssid_len;
642 params->num_ssids = wpa_s->num_ssids_from_scan_req;
643 wpa_s->num_ssids_from_scan_req = 0;
650 struct wpa_supplicant *wpa_s = eloop_ctx;
659 if (wpa_s->pno || wpa_s->pno_sched_pending) {
660 wpa_dbg(wpa_s, MSG_DEBUG, "Skip scan - PNO is in progress");
664 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
665 wpa_dbg(wpa_s, MSG_DEBUG, "Skip scan - interface disabled");
669 if (wpa_s->disconnected && wpa_s->scan_req == NORMAL_SCAN_REQ) {
670 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnected - do not scan");
671 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
675 if (wpa_s->scanning) {
680 wpa_dbg(wpa_s, MSG_DEBUG, "Already scanning - Reschedule the incoming scan req");
681 wpa_supplicant_req_scan(wpa_s, 1, 0);
685 if (!wpa_supplicant_enabled_networks(wpa_s) &&
686 wpa_s->scan_req == NORMAL_SCAN_REQ) {
687 wpa_dbg(wpa_s, MSG_DEBUG, "No enabled networks - do not scan");
688 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
692 if (wpa_s->conf->ap_scan != 0 &&
693 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)) {
694 wpa_dbg(wpa_s, MSG_DEBUG, "Using wired authentication - "
696 wpa_s->conf->ap_scan = 0;
697 wpas_notify_ap_scan_changed(wpa_s);
700 if (wpa_s->conf->ap_scan == 0) {
701 wpa_supplicant_gen_assoc_event(wpa_s);
706 if (wpa_s->scan_req != MANUAL_SCAN_REQ &&
707 wpa_s->connect_without_scan) {
709 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
710 if (ssid == wpa_s->connect_without_scan)
715 p2p_in_prog = wpas_p2p_in_progress(wpa_s);
719 wpa_dbg(wpa_s, MSG_DEBUG, "Delay station mode scan while P2P operation is in progress");
720 wpa_supplicant_req_scan(wpa_s, 5, 0);
724 if (wpa_s->conf->ap_scan == 2)
727 max_ssids = wpa_s->max_scan_ssids;
732 wpa_s->last_scan_req = wpa_s->scan_req;
733 wpa_s->scan_req = NORMAL_SCAN_REQ;
736 wpa_s->connect_without_scan = NULL;
740 wpa_supplicant_associate(wpa_s, NULL, ssid);
747 wpa_s->scan_prev_wpa_state = wpa_s->wpa_state;
748 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
749 wpa_s->wpa_state == WPA_INACTIVE)
750 wpa_supplicant_set_state(wpa_s, WPA_SCANNING);
755 if (wpa_s->autoscan_params != NULL) {
756 scan_params = wpa_s->autoscan_params;
760 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
761 wpa_set_ssids_from_scan_req(wpa_s, ¶ms, max_ssids)) {
767 if ((wpa_s->p2p_in_provisioning || wpa_s->show_group_started) &&
768 wpa_s->go_params && !wpa_s->conf->passive_scan) {
770 wpa_s->p2p_in_provisioning,
771 wpa_s->show_group_started);
772 params.ssids[0].ssid = wpa_s->go_params->ssid;
773 params.ssids[0].ssid_len = wpa_s->go_params->ssid_len;
778 if (wpa_s->p2p_in_invitation) {
779 if (wpa_s->current_ssid) {
781 params.ssids[0].ssid = wpa_s->current_ssid->ssid;
783 wpa_s->current_ssid->ssid_len;
793 ssid = wpa_s->conf->ssid;
794 if (wpa_s->prev_scan_ssid != WILDCARD_SSID_SCAN) {
796 if (ssid == wpa_s->prev_scan_ssid) {
804 if (wpa_s->last_scan_req != MANUAL_SCAN_REQ &&
805 wpa_s->conf->ap_scan == 2) {
806 wpa_s->connect_without_scan = NULL;
807 wpa_s->prev_scan_wildcard = 0;
808 wpa_supplicant_assoc_try(wpa_s, ssid);
810 } else if (wpa_s->conf->ap_scan == 2) {
816 } else if (wpa_s->reattach && wpa_s->current_ssid != NULL) {
822 ssid = wpa_s->current_ssid;
835 wpa_dbg(wpa_s, MSG_ERROR, "Memory allocation failed");
838 params.freqs[0] = wpa_s->assoc_freq;
845 wpa_s->reattach = 0;
850 ssid = wpa_s->conf->ssid;
852 if (!wpas_network_disabled(wpa_s, ssid) &&
868 start != wpa_s->conf->ssid)
869 ssid = wpa_s->conf->ssid;
872 if (wpa_s->scan_id_count &&
873 wpa_s->last_scan_req == MANUAL_SCAN_REQ)
874 wpa_set_scan_ssids(wpa_s, ¶ms, max_ssids);
876 for (tssid = wpa_s->conf->ssid;
877 wpa_s->last_scan_req != MANUAL_SCAN_REQ && tssid;
879 if (wpas_network_disabled(wpa_s, tssid))
899 if (!wpa_s->prev_scan_wildcard) {
902 wpa_s->prev_scan_wildcard = 1;
903 wpa_dbg(wpa_s, MSG_DEBUG, "Starting AP scan for "
906 wpa_s->prev_scan_ssid = ssid;
907 wpa_s->prev_scan_wildcard = 0;
908 wpa_dbg(wpa_s, MSG_DEBUG,
915 wpa_s->prev_scan_ssid = ssid;
916 wpa_dbg(wpa_s, MSG_DEBUG, "Include wildcard SSID in "
919 } else if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
920 wpa_s->manual_scan_passive && params.num_ssids == 0) {
921 wpa_dbg(wpa_s, MSG_DEBUG, "Use passive scan based on manual request");
922 } else if (wpa_s->conf->passive_scan) {
923 wpa_dbg(wpa_s, MSG_DEBUG,
926 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
928 wpa_dbg(wpa_s, MSG_DEBUG, "Starting AP scan for wildcard "
933 wpa_supplicant_optimize_freqs(wpa_s, ¶ms);
934 extra_ie = wpa_supplicant_extra_ies(wpa_s);
936 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
937 wpa_s->manual_scan_only_new) {
943 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ && params.freqs == NULL &&
944 wpa_s->manual_scan_freqs) {
945 wpa_dbg(wpa_s, MSG_DEBUG, "Limit manual scan to specified channels");
946 params.freqs = wpa_s->manual_scan_freqs;
947 wpa_s->manual_scan_freqs = NULL;
950 if (params.freqs == NULL && wpa_s->next_scan_freqs) {
951 wpa_dbg(wpa_s, MSG_DEBUG, "Optimize scan based on previously "
953 params.freqs = wpa_s->next_scan_freqs;
955 os_free(wpa_s->next_scan_freqs);
956 wpa_s->next_scan_freqs = NULL;
957 wpa_setband_scan_freqs(wpa_s, ¶ms);
960 if (wpa_s->conf->freq_list && !params.freqs) {
961 wpa_dbg(wpa_s, MSG_DEBUG,
963 int_array_concat(¶ms.freqs, wpa_s->conf->freq_list);
967 if (wpa_s->conf->scan_cur_freq && !params.freqs) {
968 unsigned int num = wpa_s->num_multichan_concurrent;
972 num = get_shared_radio_freqs(wpa_s, params.freqs, num);
974 wpa_dbg(wpa_s, MSG_DEBUG, "Scan only the "
985 wpa_s->conf, ¶ms.num_filter_ssids);
992 if (wpa_s->p2p_in_provisioning || wpa_s->p2p_in_invitation ||
993 (wpa_s->show_group_started && wpa_s->go_params)) {
1002 if (wpa_s->mac_addr_rand_enable & MAC_ADDR_RAND_SCAN) {
1004 if (wpa_s->mac_addr_scan) {
1005 params.mac_addr = wpa_s->mac_addr_scan;
1006 params.mac_addr_mask = wpa_s->mac_addr_scan + ETH_ALEN;
1016 * virtual interface that shares the same radio with the wpa_s interface
1023 if (wpa_s->scan_for_connection &&
1024 wpa_s->last_scan_req == NORMAL_SCAN_REQ &&
1026 wpas_is_p2p_prioritized(wpa_s) &&
1027 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE &&
1028 non_p2p_network_enabled(wpa_s)) {
1029 unsigned int num = wpa_s->num_multichan_concurrent;
1033 num = get_shared_radio_freqs(wpa_s, params.freqs, num);
1034 if (num > 0 && num == wpa_s->num_multichan_concurrent) {
1035 wpa_dbg(wpa_s, MSG_DEBUG, "Scan only the current operating channels since all channels are already used");
1044 ret = wpa_supplicant_trigger_scan(wpa_s, scan_params);
1046 if (ret && wpa_s->last_scan_req == MANUAL_SCAN_REQ && params.freqs &&
1047 !wpa_s->manual_scan_freqs) {
1049 wpa_s->manual_scan_freqs = params.freqs;
1058 wpa_msg(wpa_s, MSG_WARNING, "Failed to initiate AP scan");
1059 if (wpa_s->scan_prev_wpa_state != wpa_s->wpa_state)
1060 wpa_supplicant_set_state(wpa_s,
1061 wpa_s->scan_prev_wpa_state);
1063 wpa_s->scan_req = wpa_s->last_scan_req;
1064 wpa_supplicant_req_scan(wpa_s, 1, 0);
1066 wpa_s->scan_for_connection = 0;
1068 wpa_s->interworking_fast_assoc_tried = 0;
1074 void wpa_supplicant_update_scan_int(struct wpa_supplicant *wpa_s, int sec)
1079 cancelled = eloop_cancel_timeout_one(wpa_supplicant_scan, wpa_s, NULL,
1091 wpa_supplicant_scan, wpa_s, NULL);
1093 wpa_s->scan_interval = sec;
1099 * @wpa_s: Pointer to wpa_supplicant data
1106 void wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec)
1110 if (wpa_s->p2p_mgmt) {
1111 wpa_dbg(wpa_s, MSG_DEBUG,
1117 res = eloop_deplete_timeout(sec, usec, wpa_supplicant_scan, wpa_s,
1120 wpa_dbg(wpa_s, MSG_DEBUG, "Rescheduling scan request: %d.%06d sec",
1123 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore new scan request for %d.%06d sec since an earlier request is scheduled to trigger sooner",
1126 wpa_dbg(wpa_s, MSG_DEBUG, "Setting scan request: %d.%06d sec",
1128 eloop_register_timeout(sec, usec, wpa_supplicant_scan, wpa_s, NULL);
1135 * @wpa_s: Pointer to wpa_supplicant data
1143 int wpa_supplicant_delayed_sched_scan(struct wpa_supplicant *wpa_s,
1146 if (!wpa_s->sched_scan_supported)
1151 wpa_s, NULL);
1159 * @wpa_s: Pointer to wpa_supplicant data
1165 int wpa_supplicant_req_sched_scan(struct wpa_supplicant *wpa_s)
1177 if (!wpa_s->sched_scan_supported)
1180 if (wpa_s->max_sched_scan_ssids > WPAS_MAX_SCAN_SSIDS)
1183 max_sched_scan_ssids = wpa_s->max_sched_scan_ssids;
1184 if (max_sched_scan_ssids < 1 || wpa_s->conf->disable_scan_offload)
1187 if (wpa_s->sched_scanning) {
1188 wpa_dbg(wpa_s, MSG_DEBUG, "Already sched scanning");
1193 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1194 if (!wpas_network_disabled(wpa_s, ssid) && !ssid->scan_ssid) {
1197 } else if (!wpas_network_disabled(wpa_s, ssid) &&
1202 if (!wpas_network_disabled(wpa_s, ssid) &&
1210 wpa_dbg(wpa_s, MSG_DEBUG, "Use normal scan instead of "
1219 if (wpa_s->normal_scans < 3 &&
1220 (need_ssids <= wpa_s->max_scan_ssids ||
1221 wpa_s->max_scan_ssids >= (int) max_sched_scan_ssids)) {
1229 wpa_dbg(wpa_s, MSG_DEBUG, "Use normal scan instead of "
1231 wpa_s->normal_scans);
1238 params.filter_ssids = os_calloc(wpa_s->max_match_sets,
1241 prev_state = wpa_s->wpa_state;
1242 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
1243 wpa_s->wpa_state == WPA_INACTIVE)
1244 wpa_supplicant_set_state(wpa_s, WPA_SCANNING);
1246 if (wpa_s->autoscan_params != NULL) {
1247 scan_params = wpa_s->autoscan_params;
1252 ssid = wpa_s->conf->ssid;
1253 if (wpa_s->prev_sched_ssid) {
1255 if (ssid == wpa_s->prev_sched_ssid) {
1263 if (!ssid || !wpa_s->prev_sched_ssid) {
1264 wpa_dbg(wpa_s, MSG_DEBUG, "Beginning of SSID list");
1265 if (wpa_s->conf->sched_scan_interval)
1266 wpa_s->sched_scan_interval =
1267 wpa_s->conf->sched_scan_interval;
1268 if (wpa_s->sched_scan_interval == 0)
1269 wpa_s->sched_scan_interval = 10;
1270 wpa_s->sched_scan_timeout = max_sched_scan_ssids * 2;
1271 wpa_s->first_sched_scan = 1;
1272 ssid = wpa_s->conf->ssid;
1273 wpa_s->prev_sched_ssid = ssid;
1277 wpa_dbg(wpa_s, MSG_DEBUG, "Add wildcard SSID to sched_scan");
1282 if (wpas_network_disabled(wpa_s, ssid))
1285 if (params.num_filter_ssids < wpa_s->max_match_sets &&
1287 wpa_dbg(wpa_s, MSG_DEBUG, "add to filter ssid: %s",
1296 wpa_dbg(wpa_s, MSG_DEBUG, "Not enough room for SSID "
1306 wpa_dbg(wpa_s, MSG_DEBUG,
1315 wpa_s->prev_sched_ssid = ssid;
1319 (wpas_network_disabled(wpa_s, ssid) ||
1326 wpa_s->prev_sched_ssid = ssid;
1335 extra_ie = wpa_supplicant_extra_ies(wpa_s);
1341 if (wpa_s->conf->filter_rssi)
1342 params.filter_rssi = wpa_s->conf->filter_rssi;
1345 if (wpa_s->conf->freq_list && !params.freqs) {
1346 wpa_dbg(wpa_s, MSG_DEBUG,
1348 int_array_concat(¶ms.freqs, wpa_s->conf->freq_list);
1354 if (ssid || !wpa_s->first_sched_scan) {
1355 wpa_dbg(wpa_s, MSG_DEBUG,
1357 wpa_s->sched_scan_interval, wpa_s->sched_scan_timeout);
1359 wpa_dbg(wpa_s, MSG_DEBUG,
1361 wpa_s->sched_scan_interval);
1364 wpa_setband_scan_freqs(wpa_s, scan_params);
1366 if (wpa_s->mac_addr_rand_enable & MAC_ADDR_RAND_SCHED_SCAN) {
1368 if (wpa_s->mac_addr_sched_scan) {
1369 params.mac_addr = wpa_s->mac_addr_sched_scan;
1370 params.mac_addr_mask = wpa_s->mac_addr_sched_scan +
1375 ret = wpa_supplicant_start_sched_scan(wpa_s, scan_params,
1376 wpa_s->sched_scan_interval);
1380 wpa_msg(wpa_s, MSG_WARNING, "Failed to initiate sched scan");
1381 if (prev_state != wpa_s->wpa_state)
1382 wpa_supplicant_set_state(wpa_s, prev_state);
1387 if (ssid || !wpa_s->first_sched_scan) {
1388 wpa_s->sched_scan_timed_out = 0;
1389 eloop_register_timeout(wpa_s->sched_scan_timeout, 0,
1391 wpa_s, NULL);
1392 wpa_s->first_sched_scan = 0;
1393 wpa_s->sched_scan_timeout /= 2;
1394 wpa_s->sched_scan_interval *= 2;
1395 if (wpa_s->sched_scan_timeout < wpa_s->sched_scan_interval) {
1396 wpa_s->sched_scan_interval = 10;
1397 wpa_s->sched_scan_timeout = max_sched_scan_ssids * 2;
1403 wpa_s->prev_sched_ssid = NULL;
1411 * @wpa_s: Pointer to wpa_supplicant data
1416 void wpa_supplicant_cancel_scan(struct wpa_supplicant *wpa_s)
1418 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling scan request");
1419 eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
1425 * @wpa_s: Pointer to wpa_supplicant data
1429 void wpa_supplicant_cancel_delayed_sched_scan(struct wpa_supplicant *wpa_s)
1431 if (!wpa_s->sched_scan_supported)
1434 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling delayed sched scan");
1436 wpa_s, NULL);
1442 * @wpa_s: Pointer to wpa_supplicant data
1446 void wpa_supplicant_cancel_sched_scan(struct wpa_supplicant *wpa_s)
1448 if (!wpa_s->sched_scanning)
1451 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling sched scan");
1452 eloop_cancel_timeout(wpa_supplicant_sched_scan_timeout, wpa_s, NULL);
1453 wpa_supplicant_stop_sched_scan(wpa_s);
1459 * @wpa_s: Pointer to wpa_supplicant data
1467 void wpa_supplicant_notify_scanning(struct wpa_supplicant *wpa_s,
1470 if (wpa_s->scanning != scanning) {
1471 wpa_s->scanning = scanning;
1472 wpas_notify_scanning(wpa_s);
1801 * @wpa_s: Pointer to wpa_supplicant data
1808 int wpa_supplicant_filter_bssid_match(struct wpa_supplicant *wpa_s,
1813 if (wpa_s->bssid_filter == NULL)
1816 for (i = 0; i < wpa_s->bssid_filter_count; i++) {
1817 if (os_memcmp(wpa_s->bssid_filter + i * ETH_ALEN, bssid,
1826 static void filter_scan_res(struct wpa_supplicant *wpa_s,
1831 if (wpa_s->bssid_filter == NULL)
1835 if (wpa_supplicant_filter_bssid_match(wpa_s,
1944 static void scan_est_throughput(struct wpa_supplicant *wpa_s,
1947 enum local_hw_capab capab = wpa_s->hw_capab;
2036 * @wpa_s: Pointer to wpa_supplicant data
2042 * the local BSS list wpa_s->bss. The caller is responsible for freeing the
2046 wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s,
2053 scan_res = wpa_drv_get_scan_results2(wpa_s);
2055 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to get scan results");
2065 filter_scan_res(wpa_s, scan_res);
2071 scan_est_throughput(wpa_s, scan_res_item);
2075 if (wpas_wps_searching(wpa_s)) {
2076 wpa_dbg(wpa_s, MSG_DEBUG, "WPS: Order scan results with WPS "
2086 wpa_bss_update_start(wpa_s);
2088 wpa_bss_update_scan_res(wpa_s, scan_res->res[i],
2090 wpa_bss_update_end(wpa_s, info, new_scan);
2098 * @wpa_s: Pointer to wpa_supplicant data
2108 int wpa_supplicant_update_scan_results(struct wpa_supplicant *wpa_s)
2111 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
2123 void scan_only_handler(struct wpa_supplicant *wpa_s,
2126 wpa_dbg(wpa_s, MSG_DEBUG, "Scan-only results received");
2127 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
2128 wpa_s->manual_scan_use_id && wpa_s->own_scan_running) {
2129 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS "id=%u",
2130 wpa_s->manual_scan_id);
2131 wpa_s->manual_scan_use_id = 0;
2133 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS);
2135 wpas_notify_scan_results(wpa_s);
2136 wpas_notify_scan_done(wpa_s, 1);
2137 if (wpa_s->scan_work) {
2138 struct wpa_radio_work *work = wpa_s->scan_work;
2139 wpa_s->scan_work = NULL;
2145 int wpas_scan_scheduled(struct wpa_supplicant *wpa_s)
2147 return eloop_is_timeout_registered(wpa_supplicant_scan, wpa_s, NULL);
2256 int wpas_start_pno(struct wpa_supplicant *wpa_s)
2263 if (!wpa_s->sched_scan_supported)
2266 if (wpa_s->pno || wpa_s->pno_sched_pending)
2269 if ((wpa_s->wpa_state > WPA_SCANNING) &&
2270 (wpa_s->wpa_state <= WPA_COMPLETED)) {
2275 if (wpa_s->wpa_state == WPA_SCANNING) {
2276 wpa_supplicant_cancel_scan(wpa_s);
2277 if (wpa_s->sched_scanning) {
2280 wpa_supplicant_cancel_sched_scan(wpa_s);
2281 wpa_s->pno_sched_pending = 1;
2289 ssid = wpa_s->conf->ssid;
2291 if (!wpas_network_disabled(wpa_s, ssid)) {
2315 if (num_match_ssid > wpa_s->max_match_sets) {
2316 num_match_ssid = wpa_s->max_match_sets;
2317 wpa_dbg(wpa_s, MSG_DEBUG, "PNO: Too many SSIDs to match");
2326 ssid = wpa_s->conf->pssid[prio];
2328 if (!wpas_network_disabled(wpa_s, ssid)) {
2346 else if (prio + 1 == wpa_s->conf->num_prio)
2349 ssid = wpa_s->conf->pssid[++prio];
2352 if (wpa_s->conf->filter_rssi)
2353 params.filter_rssi = wpa_s->conf->filter_rssi;
2355 interval = wpa_s->conf->sched_scan_interval ?
2356 wpa_s->conf->sched_scan_interval : 10;
2358 if (params.freqs == NULL && wpa_s->manual_sched_scan_freqs) {
2359 wpa_dbg(wpa_s, MSG_DEBUG, "Limit sched scan to specified channels");
2360 params.freqs = wpa_s->manual_sched_scan_freqs;
2363 if (wpa_s->mac_addr_rand_enable & MAC_ADDR_RAND_PNO) {
2365 if (wpa_s->mac_addr_pno) {
2366 params.mac_addr = wpa_s->mac_addr_pno;
2367 params.mac_addr_mask = wpa_s->mac_addr_pno + ETH_ALEN;
2371 ret = wpa_supplicant_start_sched_scan(wpa_s, ¶ms, interval);
2374 wpa_s->pno = 1;
2376 wpa_msg(wpa_s, MSG_ERROR, "Failed to schedule PNO");
2381 int wpas_stop_pno(struct wpa_supplicant *wpa_s)
2385 if (!wpa_s->pno)
2388 ret = wpa_supplicant_stop_sched_scan(wpa_s);
2390 wpa_s->pno = 0;
2391 wpa_s->pno_sched_pending = 0;
2393 if (wpa_s->wpa_state == WPA_SCANNING)
2394 wpa_supplicant_req_scan(wpa_s, 0, 0);
2400 void wpas_mac_addr_rand_scan_clear(struct wpa_supplicant *wpa_s,
2404 wpa_s->mac_addr_rand_enable &= ~type;
2407 os_free(wpa_s->mac_addr_scan);
2408 wpa_s->mac_addr_scan = NULL;
2412 os_free(wpa_s->mac_addr_sched_scan);
2413 wpa_s->mac_addr_sched_scan = NULL;
2417 os_free(wpa_s->mac_addr_pno);
2418 wpa_s->mac_addr_pno = NULL;
2423 int wpas_mac_addr_rand_scan_set(struct wpa_supplicant *wpa_s,
2429 wpas_mac_addr_rand_scan_clear(wpa_s, type);
2440 wpa_s->mac_addr_scan = tmp;
2442 wpa_s
2444 wpa_s->mac_addr_pno = tmp;
2453 wpa_s->mac_addr_rand_enable |= type;
