Lines Matching refs:wpa_s
27 static void wpa_supplicant_gen_assoc_event(struct wpa_supplicant *wpa_s)
32 ssid = wpa_supplicant_get_ssid(wpa_s);
36 if (wpa_s->current_ssid == NULL) {
37 wpa_s->current_ssid = ssid;
38 if (wpa_s->current_ssid != NULL)
39 wpas_notify_network_changed(wpa_s);
41 wpa_supplicant_initiate_eapol(wpa_s);
42 wpa_dbg(wpa_s, MSG_DEBUG, "Already associated with a configured "
45 wpa_supplicant_event(wpa_s, EVENT_ASSOC, &data);
50 static int wpas_wps_in_use(struct wpa_supplicant *wpa_s,
56 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
70 if (!wpa_s->global->p2p_disabled && wpa_s->global->p2p &&
71 !wpa_s->conf->p2p_disabled) {
72 wpa_s->wps->dev.p2p = 1;
87 * @wpa_s: Pointer to wpa_supplicant data
94 int wpa_supplicant_enabled_networks(struct wpa_supplicant *wpa_s)
96 struct wpa_ssid *ssid = wpa_s->conf->ssid;
99 if (!wpas_network_disabled(wpa_s, ssid))
105 if (wpa_s->conf->cred && wpa_s->conf->interworking &&
106 wpa_s->conf->auto_interworking)
109 wpa_dbg(wpa_s, MSG_DEBUG, "No enabled networks (%d disabled "
116 static void wpa_supplicant_assoc_try(struct wpa_supplicant *wpa_s,
120 if (!wpas_network_disabled(wpa_s, ssid))
127 wpa_dbg(wpa_s, MSG_DEBUG, "wpa_supplicant_assoc_try: Reached "
129 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
130 wpa_supplicant_req_scan(wpa_s, 0, 0);
135 wpa_s->prev_scan_ssid = ssid;
138 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
140 wpa_supplicant_associate(wpa_s, NULL, ssid);
214 * @wpa_s: Pointer to wpa_supplicant data
218 int wpa_supplicant_trigger_scan(struct wpa_supplicant *wpa_s,
223 wpa_supplicant_notify_scanning(wpa_s, 1);
225 ret = wpa_drv_scan(wpa_s, params);
227 wpa_supplicant_notify_scanning(wpa_s, 0);
228 wpas_notify_scan_done(wpa_s, 0);
230 os_get_time(&wpa_s->scan_trigger_time);
231 wpa_s->scan_runs++;
232 wpa_s->normal_scans++;
242 struct wpa_supplicant *wpa_s = eloop_ctx;
244 wpa_dbg(wpa_s, MSG_DEBUG, "Starting delayed sched scan");
246 if (wpa_supplicant_req_sched_scan(wpa_s))
247 wpa_supplicant_req_scan(wpa_s, 0, 0);
254 struct wpa_supplicant *wpa_s = eloop_ctx;
256 wpa_dbg(wpa_s, MSG_DEBUG, "Sched scan timeout - stopping it");
258 wpa_s->sched_scan_timed_out = 1;
259 wpa_supplicant_cancel_sched_scan(wpa_s);
264 wpa_supplicant_start_sched_scan(struct wpa_supplicant *wpa_s,
270 wpa_supplicant_notify_scanning(wpa_s, 1);
271 ret = wpa_drv_sched_scan(wpa_s, params, interval * 1000);
273 wpa_supplicant_notify_scanning(wpa_s, 0);
275 wpa_s->sched_scanning = 1;
282 static int wpa_supplicant_stop_sched_scan(struct wpa_supplicant *wpa_s)
286 ret = wpa_drv_stop_sched_scan(wpa_s);
288 wpa_dbg(wpa_s, MSG_DEBUG, "stopping sched_scan failed!");
331 struct wpa_supplicant *wpa_s, struct wpa_driver_scan_params *params)
334 if (params->freqs == NULL && wpa_s->p2p_in_provisioning &&
335 wpa_s->go_params) {
337 if (wpa_s->p2p_in_provisioning < 5 &&
338 wpa_s->go_params->freq > 0) {
339 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Scan only GO "
341 wpa_s->go_params->freq);
344 params->freqs[0] = wpa_s->go_params->freq;
345 } else if (wpa_s->p2p_in_provisioning < 8 &&
346 wpa_s->go_params->freq_list[0]) {
347 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Scan only common "
350 wpa_s->go_params->freq_list);
354 wpa_s->p2p_in_provisioning++;
359 if (params->freqs == NULL && wpa_s->after_wps && wpa_s->wps_freq) {
364 wpa_dbg(wpa_s, MSG_DEBUG, "WPS: Scan only frequency %u MHz "
365 "that was used during provisioning", wpa_s->wps_freq);
368 params->freqs[0] = wpa_s->wps_freq;
369 wpa_s->after_wps--;
372 if (params->freqs == NULL && wpa_s->known_wps_freq && wpa_s->wps_freq)
375 wpa_dbg(wpa_s, MSG_DEBUG, "WPS: Scan only frequency %u MHz",
376 wpa_s->wps_freq);
379 params->freqs[0] = wpa_s->wps_freq;
380 wpa_s->known_wps_freq = 0; /* only do this once */
387 static void wpas_add_interworking_elements(struct wpa_supplicant *wpa_s,
390 if (wpa_s->conf->interworking == 0)
401 wpabuf_put_u8(buf, is_zero_ether_addr(wpa_s->conf->hessid) ? 1 :
403 wpabuf_put_u8(buf, wpa_s->conf->access_network_type);
405 if (!is_zero_ether_addr(wpa_s->conf->hessid))
406 wpabuf_put_data(buf, wpa_s->conf->hessid, ETH_ALEN);
411 static struct wpabuf * wpa_supplicant_extra_ies(struct wpa_supplicant *wpa_s)
420 if (wpa_s->conf->interworking &&
422 wpas_add_interworking_elements(wpa_s, extra_ie);
426 wps = wpas_wps_in_use(wpa_s, &req_type);
432 &wpa_s->wps->dev,
433 wpa_s->wps->uuid, req_type,
444 size_t ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
446 wpas_p2p_scan_ie(wpa_s, extra_ie);
453 if (wpa_s->conf->hs20 && wpabuf_resize(&extra_ie, 7) == 0)
467 static int non_p2p_network_enabled(struct wpa_supplicant *wpa_s)
471 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
472 if (wpas_network_disabled(wpa_s, ssid))
478 if (wpa_s->conf->cred && wpa_s->conf->interworking &&
479 wpa_s->conf->auto_interworking)
503 static void wpa_setband_scan_freqs_list(struct wpa_supplicant *wpa_s,
511 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, band);
529 static void wpa_setband_scan_freqs(struct wpa_supplicant *wpa_s,
532 if (wpa_s->hw.modes == NULL)
536 if (wpa_s->setband == WPA_SETBAND_5G)
537 wpa_setband_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211A,
539 else if (wpa_s->setband == WPA_SETBAND_2G)
540 wpa_setband_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211G,
547 struct wpa_supplicant *wpa_s = eloop_ctx;
557 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
558 wpa_dbg(wpa_s, MSG_DEBUG, "Skip scan - interface disabled");
559 wpas_p2p_continue_after_scan(wpa_s);
563 if (wpa_s->disconnected && wpa_s->scan_req == NORMAL_SCAN_REQ) {
564 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnected - do not scan");
565 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
566 wpas_p2p_continue_after_scan(wpa_s);
570 if (wpa_s->scanning) {
572 wpa_dbg(wpa_s, MSG_DEBUG, "Skip scan - already scanning");
576 if (!wpa_supplicant_enabled_networks(wpa_s) &&
577 wpa_s->scan_req == NORMAL_SCAN_REQ) {
578 wpa_dbg(wpa_s, MSG_DEBUG, "No enabled networks - do not scan");
579 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
580 wpas_p2p_continue_after_scan(wpa_s);
584 if (wpa_s->conf->ap_scan != 0 &&
585 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)) {
586 wpa_dbg(wpa_s, MSG_DEBUG, "Using wired authentication - "
588 wpa_s->conf->ap_scan = 0;
589 wpas_notify_ap_scan_changed(wpa_s);
592 if (wpa_s->conf->ap_scan == 0) {
593 wpa_supplicant_gen_assoc_event(wpa_s);
598 if (wpas_p2p_in_progress(wpa_s) || wpas_wpa_is_in_progress(wpa_s)) {
599 if (wpa_s->sta_scan_pending &&
600 wpas_p2p_in_progress(wpa_s) == 2 &&
601 wpa_s->global->p2p_cb_on_scan_complete) {
602 wpa_dbg(wpa_s, MSG_DEBUG, "Process pending station "
605 wpa_dbg(wpa_s, MSG_DEBUG, "Delay station mode scan "
607 wpa_s->sta_scan_pending = 1;
608 wpa_supplicant_req_scan(wpa_s, 5, 0);
614 if (wpa_s->conf->ap_scan == 2)
617 max_ssids = wpa_s->max_scan_ssids;
622 scan_req = wpa_s->scan_req;
623 wpa_s->scan_req = NORMAL_SCAN_REQ;
627 prev_state = wpa_s->wpa_state;
628 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
629 wpa_s->wpa_state == WPA_INACTIVE)
630 wpa_supplicant_set_state(wpa_s, WPA_SCANNING);
635 if (wpa_s->autoscan_params != NULL) {
636 scan_params = wpa_s->autoscan_params;
640 if (scan_req != MANUAL_SCAN_REQ && wpa_s->connect_without_scan) {
641 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
642 if (ssid == wpa_s->connect_without_scan)
645 wpa_s->connect_without_scan = NULL;
649 wpa_supplicant_associate(wpa_s, NULL, ssid);
655 if ((wpa_s->p2p_in_provisioning || wpa_s->show_group_started) &&
656 wpa_s->go_params) {
659 params.ssids[0].ssid = wpa_s->go_params->ssid;
660 params.ssids[0].ssid_len = wpa_s->go_params->ssid_len;
667 ssid = wpa_s->conf->ssid;
668 if (wpa_s->prev_scan_ssid != WILDCARD_SSID_SCAN) {
670 if (ssid == wpa_s
678 if (scan_req != MANUAL_SCAN_REQ && wpa_s->conf->ap_scan == 2) {
679 wpa_s->connect_without_scan = NULL;
680 wpa_s->prev_scan_wildcard = 0;
681 wpa_supplicant_assoc_try(wpa_s, ssid);
684 } else if (wpa_s->conf->ap_scan == 2) {
695 ssid = wpa_s->conf->ssid;
697 if (!wpas_network_disabled(wpa_s, ssid) &&
713 start != wpa_s->conf->ssid)
714 ssid = wpa_s->conf->ssid;
717 for (tssid = wpa_s->conf->ssid; tssid; tssid = tssid->next) {
718 if (wpas_network_disabled(wpa_s, tssid))
738 if (!wpa_s->prev_scan_wildcard) {
741 wpa_s->prev_scan_wildcard = 1;
742 wpa_dbg(wpa_s, MSG_DEBUG, "Starting AP scan for "
745 wpa_s->prev_scan_ssid = ssid;
746 wpa_s->prev_scan_wildcard = 0;
747 wpa_dbg(wpa_s, MSG_DEBUG,
754 wpa_s->prev_scan_ssid = ssid;
755 wpa_dbg(wpa_s, MSG_DEBUG, "Include wildcard SSID in "
759 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
761 wpa_dbg(wpa_s, MSG_DEBUG, "Starting AP scan for wildcard "
768 wpa_supplicant_optimize_freqs(wpa_s, ¶ms);
769 extra_ie = wpa_supplicant_extra_ies(wpa_s);
771 if (params.freqs == NULL && wpa_s->next_scan_freqs) {
772 wpa_dbg(wpa_s, MSG_DEBUG, "Optimize scan based on previously "
774 params.freqs = wpa_s->next_scan_freqs;
776 os_free(wpa_s->next_scan_freqs);
777 wpa_s->next_scan_freqs = NULL;
778 wpa_setband_scan_freqs(wpa_s, ¶ms);
781 if (wpa_s->conf->freq_list && !params.freqs) {
782 wpa_dbg(wpa_s, MSG_DEBUG,
784 int_array_concat(¶ms.freqs, wpa_s->conf->freq_list);
788 if (wpa_s->conf->scan_cur_freq && !params.freqs) {
789 unsigned int num = wpa_s->num_multichan_concurrent;
793 num = get_shared_radio_freqs(wpa_s, params.freqs, num);
795 wpa_dbg(wpa_s, MSG_DEBUG, "Scan only the "
806 wpa_s->conf, ¶ms.num_filter_ssids);
813 if (wpa_s->p2p_in_provisioning ||
814 (wpa_s->show_group_started && wpa_s->go_params)) {
829 * virtual interface that shares the same radio with the wpa_s interface
836 if (wpa_s->scan_for_connection && scan_req == NORMAL_SCAN_REQ &&
838 wpas_is_p2p_prioritized(wpa_s) &&
839 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE &&
840 non_p2p_network_enabled(wpa_s)) {
841 unsigned int num = wpa_s->num_multichan_concurrent;
845 num = get_shared_radio_freqs(wpa_s, params.freqs, num);
846 if (num > 0 && num == wpa_s->num_multichan_concurrent) {
847 wpa_dbg(wpa_s, MSG_DEBUG, "Scan only the current operating channels since all channels are already used");
856 ret = wpa_supplicant_trigger_scan(wpa_s, scan_params);
863 wpa_msg(wpa_s, MSG_WARNING, "Failed to initiate AP scan");
864 if (prev_state != wpa_s->wpa_state)
865 wpa_supplicant_set_state(wpa_s, prev_state);
867 wpa_s->scan_req = scan_req;
868 wpa_supplicant_req_scan(wpa_s, 1, 0);
870 wpa_s->scan_for_connection = 0;
875 void wpa_supplicant_update_scan_int(struct wpa_supplicant *wpa_s, int sec)
880 cancelled = eloop_cancel_timeout_one(wpa_supplicant_scan, wpa_s, NULL,
891 wpa_s, NULL);
892 wpa_s->scan_interval = sec;
898 * @wpa_s: Pointer to wpa_supplicant data
905 void wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec)
914 if (eloop_is_timeout_registered(wpa_supplicant_scan, wpa_s, NULL) &&
915 wpa_s->conf->ap_scan == 1) {
916 struct wpa_ssid *ssid = wpa_s->conf->ssid;
919 if (!wpas_network_disabled(wpa_s, ssid) &&
925 wpa_dbg(wpa_s, MSG_DEBUG, "Not rescheduling scan to "
931 wpa_dbg(wpa_s, MSG_DEBUG, "Setting scan request: %d sec %d usec",
933 eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
934 eloop_register_timeout(sec, usec, wpa_supplicant_scan, wpa_s, NULL);
940 * @wpa_s: Pointer to wpa_supplicant data
948 int wpa_supplicant_delayed_sched_scan(struct wpa_supplicant *wpa_s,
951 if (!wpa_s->sched_scan_supported)
956 wpa_s, NULL);
964 * @wpa_s: Pointer to wpa_supplicant data
970 int wpa_supplicant_req_sched_scan(struct wpa_supplicant *wpa_s)
982 if (!wpa_s->sched_scan_supported)
985 if (wpa_s->max_sched_scan_ssids > WPAS_MAX_SCAN_SSIDS)
988 max_sched_scan_ssids = wpa_s->max_sched_scan_ssids;
989 if (max_sched_scan_ssids < 1 || wpa_s->conf->disable_scan_offload)
992 if (wpa_s->sched_scanning) {
993 wpa_dbg(wpa_s, MSG_DEBUG, "Already sched scanning");
998 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
999 if (!wpas_network_disabled(wpa_s, ssid) && !ssid->scan_ssid) {
1002 } else if (!wpas_network_disabled(wpa_s, ssid) &&
1007 if (!wpas_network_disabled(wpa_s, ssid) &&
1015 wpa_dbg(wpa_s, MSG_DEBUG, "Use normal scan instead of "
1024 if (wpa_s->normal_scans < 3 &&
1025 (need_ssids <= wpa_s->max_scan_ssids ||
1026 wpa_s->max_scan_ssids >= (int) max_sched_scan_ssids)) {
1034 wpa_dbg(wpa_s, MSG_DEBUG, "Use normal scan instead of "
1036 wpa_s->normal_scans);
1043 params.filter_ssids = os_zalloc(wpa_s->max_match_sets *
1046 prev_state = wpa_s->wpa_state;
1047 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
1048 wpa_s->wpa_state == WPA_INACTIVE)
1049 wpa_supplicant_set_state(wpa_s, WPA_SCANNING);
1051 if (wpa_s->autoscan_params != NULL) {
1052 scan_params = wpa_s->autoscan_params;
1057 ssid = wpa_s->conf->ssid;
1058 if (wpa_s->prev_sched_ssid) {
1060 if (ssid == wpa_s->prev_sched_ssid) {
1068 if (!ssid || !wpa_s->prev_sched_ssid) {
1069 wpa_dbg(wpa_s, MSG_DEBUG, "Beginning of SSID list");
1070 if (wpa_s->conf->sched_scan_interval)
1071 wpa_s->sched_scan_interval =
1072 wpa_s->conf->sched_scan_interval;
1073 if (wpa_s->sched_scan_interval == 0)
1074 wpa_s->sched_scan_interval = 10;
1075 wpa_s->sched_scan_timeout = max_sched_scan_ssids * 2;
1076 wpa_s->first_sched_scan = 1;
1077 ssid = wpa_s->conf->ssid;
1078 wpa_s->prev_sched_ssid = ssid;
1082 wpa_dbg(wpa_s, MSG_DEBUG, "Add wildcard SSID to sched_scan");
1087 if (wpas_network_disabled(wpa_s, ssid))
1090 if (params.num_filter_ssids < wpa_s->max_match_sets &&
1092 wpa_dbg(wpa_s, MSG_DEBUG, "add to filter ssid: %s",
1101 wpa_dbg(wpa_s, MSG_DEBUG, "Not enough room for SSID "
1111 wpa_dbg(wpa_s, MSG_DEBUG,
1120 wpa_s->prev_sched_ssid = ssid;
1124 (wpas_network_disabled(wpa_s, ssid) ||
1131 wpa_s->prev_sched_ssid = ssid;
1140 extra_ie = wpa_supplicant_extra_ies(wpa_s);
1149 if (ssid || !wpa_s->first_sched_scan) {
1150 wpa_dbg(wpa_s, MSG_DEBUG,
1152 wpa_s->sched_scan_interval, wpa_s->sched_scan_timeout);
1154 wpa_dbg(wpa_s, MSG_DEBUG,
1156 wpa_s->sched_scan_interval);
1159 wpa_setband_scan_freqs(wpa_s, scan_params);
1161 ret = wpa_supplicant_start_sched_scan(wpa_s, scan_params,
1162 wpa_s->sched_scan_interval);
1166 wpa_msg(wpa_s, MSG_WARNING, "Failed to initiate sched scan");
1167 if (prev_state != wpa_s->wpa_state)
1168 wpa_supplicant_set_state(wpa_s, prev_state);
1173 if (ssid || !wpa_s->first_sched_scan) {
1174 wpa_s->sched_scan_timed_out = 0;
1175 eloop_register_timeout(wpa_s->sched_scan_timeout, 0,
1177 wpa_s, NULL);
1178 wpa_s->first_sched_scan = 0;
1179 wpa_s->sched_scan_timeout /= 2;
1180 wpa_s->sched_scan_interval *= 2;
1181 if (wpa_s->sched_scan_timeout < wpa_s->sched_scan_interval) {
1182 wpa_s->sched_scan_interval = 10;
1183 wpa_s->sched_scan_timeout = max_sched_scan_ssids * 2;
1189 wpa_s->prev_sched_ssid = NULL;
1197 * @wpa_s: Pointer to wpa_supplicant data
1202 void wpa_supplicant_cancel_scan(struct wpa_supplicant *wpa_s)
1204 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling scan request");
1205 eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
1206 wpas_p2p_continue_after_scan(wpa_s);
1208 wpa_supplicant_notify_scanning(wpa_s, 0);
1215 * @wpa_s: Pointer to wpa_supplicant data
1219 void wpa_supplicant_cancel_delayed_sched_scan(struct wpa_supplicant *wpa_s)
1221 if (!wpa_s->sched_scan_supported)
1224 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling delayed sched scan");
1226 wpa_s, NULL);
1232 * @wpa_s: Pointer to wpa_supplicant data
1236 void wpa_supplicant_cancel_sched_scan(struct wpa_supplicant *wpa_s)
1238 if (!wpa_s->sched_scanning)
1241 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling sched scan");
1242 eloop_cancel_timeout(wpa_supplicant_sched_scan_timeout, wpa_s, NULL);
1243 wpa_supplicant_stop_sched_scan(wpa_s);
1249 * @wpa_s: Pointer to wpa_supplicant data
1257 void wpa_supplicant_notify_scanning(struct wpa_supplicant *wpa_s,
1260 if (wpa_s->scanning != scanning) {
1261 wpa_s->scanning = scanning;
1262 wpas_notify_scanning(wpa_s);
1555 * @wpa_s: Pointer to wpa_supplicant data
1562 int wpa_supplicant_filter_bssid_match(struct wpa_supplicant *wpa_s,
1567 if (wpa_s->bssid_filter == NULL)
1570 for (i = 0; i < wpa_s->bssid_filter_count; i++) {
1571 if (os_memcmp(wpa_s->bssid_filter + i * ETH_ALEN, bssid,
1580 static void filter_scan_res(struct wpa_supplicant *wpa_s,
1585 if (wpa_s->bssid_filter == NULL)
1589 if (wpa_supplicant_filter_bssid_match(wpa_s,
1608 * @wpa_s: Pointer to wpa_supplicant data
1614 * the local BSS list wpa_s->bss. The caller is responsible for freeing the
1618 wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s,
1625 scan_res = wpa_drv_get_scan_results2(wpa_s);
1627 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to get scan results");
1637 filter_scan_res(wpa_s, scan_res);
1640 if (wpas_wps_in_progress(wpa_s)) {
1641 wpa_dbg(wpa_s, MSG_DEBUG, "WPS: Order scan results with WPS "
1651 wpa_bss_update_start(wpa_s);
1653 wpa_bss_update_scan_res(wpa_s, scan_res->res[i],
1655 wpa_bss_update_end(wpa_s, info, new_scan);
1663 * @wpa_s: Pointer to wpa_supplicant data
1673 int wpa_supplicant_update_scan_results(struct wpa_supplicant *wpa_s)
1676 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
1688 void scan_only_handler(struct wpa_supplicant *wpa_s,
1691 wpa_dbg(wpa_s, MSG_DEBUG, "Scan-only results received");
1692 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS);
1693 wpas_notify_scan_results(wpa_s);
1694 wpas_notify_scan_done(wpa_s, 1);
1698 int wpas_scan_scheduled(struct wpa_supplicant *wpa_s)
1700 return eloop_is_timeout_registered(wpa_supplicant_scan, wpa_s, NULL);
