Lines Matching +full:max +full:- +full:bitrate
2 * WPA Supplicant - Scanning
3 * Copyright (c) 2003-2019, Jouni Malinen <j@w1.fi>
39 if (wpa_s->current_ssid == NULL) {
40 wpa_s->current_ssid = ssid;
45 "network - generating associated event");
58 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
59 if (!(ssid->key_mgmt & WPA_KEY_MGMT_WPS))
64 if (ssid->eap.phase1 && os_strstr(ssid->eap.phase1, "pbc=1"))
69 if (!wpa_s->global->p2p_disabled && wpa_s->global->p2p &&
70 !wpa_s->conf->p2p_disabled) {
71 wpa_s->wps->dev.p2p = 1;
89 if (params->mac_addr) {
90 params->mac_addr_mask = NULL;
91 os_free(params->mac_addr);
92 params->mac_addr = NULL;
95 params->mac_addr_rand = 1;
102 return -1;
105 params->mac_addr = tmp;
106 params->mac_addr_mask = tmp + ETH_ALEN;
112 * wpa_supplicant_enabled_networks - Check whether there are enabled networks
122 struct wpa_ssid *ssid = wpa_s->conf->ssid;
125 if (wpa_s->p2p_mgmt)
133 ssid = ssid->next;
135 if (wpa_s->conf->cred && wpa_s->conf->interworking &&
136 wpa_s->conf->auto_interworking)
162 ssid = ssid->next;
165 /* ap_scan=2 mode - try to associate with each SSID. */
168 "end of scan list - go back to beginning");
169 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
173 if (ssid->next) {
175 wpa_s->prev_scan_ssid = ssid;
178 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
186 struct wpa_supplicant *wpa_s = work->wpa_s;
187 struct wpa_driver_scan_params *params = work->ctx;
191 if (!work->started) {
197 wpa_s->scan_work = NULL;
201 if ((wpa_s->mac_addr_rand_enable & MAC_ADDR_RAND_SCAN) &&
202 wpa_s->wpa_state <= WPA_SCANNING)
203 wpa_setup_mac_addr_rand_params(params, wpa_s->mac_addr_scan);
209 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SCAN_FAILED "ret=-1");
216 if (wpa_s->clear_driver_scan_cache) {
219 params->only_new_results = 1;
232 wpa_s->curr_scan_cookie = params->scan_cookie;
234 work->ctx = NULL;
236 int retry = wpa_s->last_scan_req != MANUAL_SCAN_REQ &&
237 !wpa_s->beacon_rep_data.token;
239 if (wpa_s->disconnected)
243 if (ret == -EOPNOTSUPP)
248 if (wpa_s->wpa_state == WPA_SCANNING)
250 wpa_s->scan_prev_wpa_state);
257 wpa_s->scan_req = wpa_s->last_scan_req;
259 } else if (wpa_s->scan_res_handler) {
261 wpa_s->scan_res_handler = NULL;
265 if (wpa_s->beacon_rep_data.token)
272 os_get_reltime(&wpa_s->scan_trigger_time);
273 wpa_s->scan_runs++;
274 wpa_s->normal_scans++;
275 wpa_s->own_scan_requested = 1;
276 wpa_s->clear_driver_scan_cache = 0;
277 wpa_s->scan_work = work;
282 * wpa_supplicant_trigger_scan - Request driver to start a scan
289 * double-free.
291 * Returns: 0 on success, -1 on failure
300 if (wpa_s->scan_work) {
302 return -1;
306 if (params->extra_ies_len) {
307 os_free((u8 *) params->extra_ies);
308 params->extra_ies = NULL;
309 params->extra_ies_len = 0;
313 params->extra_ies = wpabuf_head(ies);
314 params->extra_ies_len = wpabuf_len(ies);
320 params->extra_ies = NULL;
321 params->extra_ies_len = 0;
323 wpa_s->last_scan_all_chan = !params->freqs;
324 wpa_s->last_scan_non_coloc_6ghz = params->non_coloc_6ghz;
326 if (wpa_s->crossed_6ghz_dom) {
328 wpa_s->crossed_6ghz_dom = false;
335 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SCAN_FAILED "ret=-1");
336 return -1;
339 wpa_s->wps_scan_done = false;
362 wpa_dbg(wpa_s, MSG_DEBUG, "Sched scan timeout - stopping it");
364 wpa_s->sched_scan_timed_out = 1;
380 wpa_s->sched_scanning = 1;
394 return -1;
409 if (!conf->filter_ssids)
412 for (count = 0, ssid = conf->ssid; ssid; ssid = ssid->next) {
413 if (ssid->ssid && ssid->ssid_len)
422 for (ssid = conf->ssid; ssid; ssid = ssid->next) {
423 if (!ssid->ssid || !ssid->ssid_len)
425 os_memcpy(ssids[*num_ssids].ssid, ssid->ssid, ssid->ssid_len);
426 ssids[*num_ssids].ssid_len = ssid->ssid_len;
438 if (params->freqs == NULL && wpa_s->p2p_in_provisioning &&
439 wpa_s->go_params) {
441 if (wpa_s->p2p_in_provisioning < 5 &&
442 wpa_s->go_params->freq > 0) {
445 wpa_s->go_params->freq);
446 params->freqs = os_calloc(2, sizeof(int));
447 if (params->freqs)
448 params->freqs[0] = wpa_s->go_params->freq;
449 } else if (wpa_s->p2p_in_provisioning < 8 &&
450 wpa_s->go_params->freq_list[0]) {
453 int_array_concat(¶ms->freqs,
454 wpa_s->go_params->freq_list);
455 if (params->freqs)
456 int_array_sort_unique(params->freqs);
458 wpa_s->p2p_in_provisioning++;
461 if (params->freqs == NULL && wpa_s->p2p_in_invitation) {
462 struct wpa_ssid *ssid = wpa_s->current_ssid;
465 * Perform a single-channel scan if the GO has already been
466 * discovered on another non-P2P interface. Note that a scan
471 if (wpa_s->p2p_in_invitation == 1 && ssid) {
474 const u8 *bssid = ssid->bssid_set ? ssid->bssid : NULL;
476 dl_list_for_each(ifs, &wpa_s->radio->ifaces,
478 bss = wpa_bss_get(ifs, bssid, ssid->ssid,
479 ssid->ssid_len);
483 if (bss && !disabled_freq(wpa_s, bss->freq)) {
484 params->freqs = os_calloc(2, sizeof(int));
485 if (params->freqs) {
488 bss->freq);
489 params->freqs[0] = bss->freq;
498 if (!params->freqs && wpa_s->p2p_in_invitation < 5 &&
499 wpa_s->p2p_invite_go_freq > 0) {
500 if (wpa_s->p2p_invite_go_freq == 2 ||
501 wpa_s->p2p_invite_go_freq == 5) {
506 wpa_s->p2p_invite_go_freq);
508 if (!wpa_s->hw.modes)
510 mode = wpa_s->p2p_invite_go_freq == 5 ?
513 if (wpa_s->p2p_in_invitation <= 2)
517 if (!params->freqs || params->freqs[0] == 0)
524 wpa_s->p2p_invite_go_freq);
525 params->freqs = os_calloc(2, sizeof(int));
526 if (params->freqs)
527 params->freqs[0] =
528 wpa_s->p2p_invite_go_freq;
531 wpa_s->p2p_in_invitation++;
532 if (wpa_s->p2p_in_invitation > 20) {
540 wpa_s->p2p_in_invitation = 0;
541 wpa_s->p2p_retry_limit = 0;
547 if (params->freqs == NULL && wpa_s->after_wps && wpa_s->wps_freq) {
549 * Optimize post-provisioning scan based on channel used
553 "that was used during provisioning", wpa_s->wps_freq);
554 params->freqs = os_calloc(2, sizeof(int));
555 if (params->freqs)
556 params->freqs[0] = wpa_s->wps_freq;
557 wpa_s->after_wps--;
558 } else if (wpa_s->after_wps)
559 wpa_s->after_wps--;
561 if (params->freqs == NULL && wpa_s->known_wps_freq && wpa_s->wps_freq)
565 wpa_s->wps_freq);
566 params->freqs = os_calloc(2, sizeof(int));
567 if (params->freqs)
568 params->freqs[0] = wpa_s->wps_freq;
569 wpa_s->known_wps_freq = 0; /* only do this once */
580 wpabuf_put_u8(buf, is_zero_ether_addr(wpa_s->conf->hessid) ? 1 :
582 wpabuf_put_u8(buf, wpa_s->conf->access_network_type);
584 if (!is_zero_ether_addr(wpa_s->conf->hessid))
585 wpabuf_put_data(buf, wpa_s->conf->hessid, ETH_ALEN);
606 /* Max Channel Time field - contains the value of MaxChannelTime
607 * parameter of the MLME-SCAN.request primitive represented in units of
608 * TUs, as an unsigned integer. A Max Channel Time field value of 255
610 * unspecified or unknown duration. (IEEE Std 802.11ai-2016, 9.4.2.178)
625 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT)
638 if (wpa_s->enable_oce & OCE_STA)
650 if (wpa_s->vendor_elem[frame_id]) {
653 len = wpabuf_len(wpa_s->vendor_elem[frame_id]);
656 wpa_s->vendor_elem[frame_id]);
718 *len_pos = (u8 *) wpabuf_put(extra_ie, 0) - len_pos - 1;
734 if (!is_zero_ether_addr(wpa_s->ml_probe_bssid)) {
735 extra_ie = wpa_supplicant_ml_probe_ie(wpa_s->ml_probe_mld_id,
736 wpa_s->ml_probe_links);
744 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT)
757 if (wpa_s->conf->interworking &&
763 if (wpa_s->enable_oce & OCE_STA)
774 &wpa_s->wps->dev,
775 wpa_s->wps->uuid, req_type,
786 size_t ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
797 if (wpa_s->conf->hs20 && wpabuf_resize(&extra_ie, 9) == 0)
798 wpas_hs20_add_indication(extra_ie, -1, 0);
802 if (wpa_s->fst_ies &&
803 wpabuf_resize(&extra_ie, wpabuf_len(wpa_s->fst_ies)) == 0)
804 wpabuf_put_buf(extra_ie, wpa_s->fst_ies);
813 if (wpa_s->vendor_elem[VENDOR_ELEM_PROBE_REQ]) {
814 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_PROBE_REQ];
828 * used for a non-P2P connection.
834 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
837 if (!ssid->p2p_group)
841 if (wpa_s->conf->cred && wpa_s->conf->interworking &&
842 wpa_s->conf->auto_interworking)
862 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, band, is_6ghz);
863 if (!mode || !mode->num_channels)
864 return -1;
866 if (params->freqs) {
867 while (params->freqs[num_chans])
871 freqs = os_realloc(params->freqs,
872 (num_chans + mode->num_channels + 1) * sizeof(int));
874 return -1;
876 params->freqs = freqs;
877 for (i = 0; i < mode->num_channels; i++) {
878 if (mode->channels[i].flag & HOSTAPD_CHAN_DISABLED)
881 (mode->channels[i].flag & HOSTAPD_CHAN_RADAR))
885 !is_6ghz_psc_frequency(mode->channels[i].freq))
888 params->freqs[num_chans++] = mode->channels[i].freq;
890 params->freqs[num_chans] = 0;
899 if (wpa_s->hw.modes == NULL)
901 if (params->freqs)
904 if (wpa_s->setband_mask & WPA_SETBAND_5G)
907 if (wpa_s->setband_mask & WPA_SETBAND_2G)
910 if (wpa_s->setband_mask & WPA_SETBAND_6G)
922 for (j = 0; j < params->num_ssids; j++) {
923 if (params->ssids[j].ssid_len == ssid_len &&
924 params->ssids[j].ssid &&
925 os_memcmp(params->ssids[j].ssid, ssid, ssid_len) == 0)
929 if (params->num_ssids + 1 > max_ssids) {
930 wpa_printf(MSG_DEBUG, "Over max scan SSIDs for manual request");
937 params->ssids[params->num_ssids].ssid = ssid;
938 params->ssids[params->num_ssids].ssid_len = ssid_len;
939 params->num_ssids++;
950 if (!(ssid->key_mgmt & WPA_KEY_MGMT_OWE))
954 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
956 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
961 if (bss->ssid_len != ssid->ssid_len ||
962 os_memcmp(bss->ssid, ssid->ssid, ssid->ssid_len) != 0)
973 if (end - pos < ETH_ALEN + 1)
981 if ((size_t) (end - pos) < owe_ssid_len ||
1008 max_ssids = max_ssids > 1 ? max_ssids - 1 : max_ssids;
1010 for (i = 0; i < wpa_s->scan_id_count; i++) {
1011 ssid = wpa_config_get_network(wpa_s->conf, wpa_s->scan_id[i]);
1014 if (ssid->scan_ssid)
1016 ssid->ssid, ssid->ssid_len);
1024 wpa_s->scan_id_count = 0;
1034 if (wpa_s->ssids_from_scan_req == NULL ||
1035 wpa_s->num_ssids_from_scan_req == 0)
1038 if (wpa_s->num_ssids_from_scan_req > max_ssids) {
1039 wpa_s->num_ssids_from_scan_req = max_ssids;
1040 wpa_printf(MSG_DEBUG, "Over max scan SSIDs from scan req: %u",
1044 for (i = 0; i < wpa_s->num_ssids_from_scan_req; i++) {
1045 params->ssids[i].ssid = wpa_s->ssids_from_scan_req[i].ssid;
1046 params->ssids[i].ssid_len =
1047 wpa_s->ssids_from_scan_req[i].ssid_len;
1049 params->ssids[i].ssid,
1050 params->ssids[i].ssid_len);
1053 params->num_ssids = wpa_s->num_ssids_from_scan_req;
1054 wpa_s->num_ssids_from_scan_req = 0;
1070 wpa_s->ignore_post_flush_scan_res = 0;
1072 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
1073 wpa_dbg(wpa_s, MSG_DEBUG, "Skip scan - interface disabled");
1077 if (wpa_s->disconnected && wpa_s->scan_req == NORMAL_SCAN_REQ) {
1078 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnected - do not scan");
1083 if (wpa_s->scanning) {
1088 wpa_dbg(wpa_s, MSG_DEBUG, "Already scanning - Reschedule the incoming scan req");
1094 wpa_s->scan_req == NORMAL_SCAN_REQ) {
1095 wpa_dbg(wpa_s, MSG_DEBUG, "No enabled networks - do not scan");
1100 if (wpa_s->conf->ap_scan != 0 &&
1101 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)) {
1102 wpa_dbg(wpa_s, MSG_DEBUG, "Using wired authentication - "
1104 wpa_s->conf->ap_scan = 0;
1108 if (wpa_s->conf->ap_scan == 0) {
1114 if (wpa_s->scan_req != MANUAL_SCAN_REQ &&
1115 wpa_s->connect_without_scan) {
1117 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1118 if (ssid == wpa_s->connect_without_scan)
1126 (ssid->mode != WPAS_MODE_AP && ssid->mode != WPAS_MODE_P2P_GO))) {
1135 * auto-reconnect, etc). Discarding the scan might hurt these processes.
1141 if (wpa_s->pno || wpa_s->pno_sched_pending) {
1142 wpa_dbg(wpa_s, MSG_DEBUG, "Defer scan - PNO is in progress");
1147 if (wpa_s->conf->ap_scan == 2)
1150 max_ssids = wpa_s->max_scan_ssids;
1155 wpa_s->last_scan_req = wpa_s->scan_req;
1156 wpa_s->scan_req = NORMAL_SCAN_REQ;
1159 wpa_s->connect_without_scan = NULL;
1161 wpa_printf(MSG_DEBUG, "Start a pre-selected network "
1170 wpa_s->scan_prev_wpa_state = wpa_s->wpa_state;
1171 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
1172 wpa_s->wpa_state == WPA_INACTIVE)
1178 if (wpa_s->autoscan_params != NULL) {
1179 scan_params = wpa_s->autoscan_params;
1183 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
1190 if ((wpa_s->p2p_in_provisioning || wpa_s->show_group_started) &&
1191 wpa_s->go_params && !wpa_s->conf->passive_scan) {
1193 wpa_s->p2p_in_provisioning,
1194 wpa_s->show_group_started);
1195 params.ssids[0].ssid = wpa_s->go_params->ssid;
1196 params.ssids[0].ssid_len = wpa_s->go_params->ssid_len;
1198 params.bssid = wpa_s->go_params->peer_interface_addr;
1205 if (wpa_s->p2p_in_invitation) {
1206 if (wpa_s->current_ssid) {
1208 params.ssids[0].ssid = wpa_s->current_ssid->ssid;
1210 wpa_s->current_ssid->ssid_len;
1212 if (wpa_s->current_ssid->bssid_set) {
1213 params.bssid = wpa_s->current_ssid->bssid;
1226 ssid = wpa_s->conf->ssid;
1227 if (wpa_s->prev_scan_ssid != WILDCARD_SSID_SCAN) {
1229 if (ssid == wpa_s->prev_scan_ssid) {
1230 ssid = ssid->next;
1233 ssid = ssid->next;
1237 if (wpa_s->last_scan_req != MANUAL_SCAN_REQ &&
1239 !wpa_s->ap_iface &&
1241 wpa_s->conf->ap_scan == 2) {
1242 wpa_s->connect_without_scan = NULL;
1243 wpa_s->prev_scan_wildcard = 0;
1246 } else if (wpa_s->conf->ap_scan == 2) {
1248 * User-initiated scan request in ap_scan == 2; scan with
1252 } else if (wpa_s->reattach && wpa_s->current_ssid != NULL) {
1254 * Perform single-channel single-SSID scan for
1255 * reassociate-to-same-BSS operation.
1258 ssid = wpa_s->current_ssid;
1260 ssid->ssid, ssid->ssid_len);
1261 params.ssids[0].ssid = ssid->ssid;
1262 params.ssids[0].ssid_len = ssid->ssid_len;
1267 * slot for the zero-terminator.
1271 params.freqs[0] = wpa_s->assoc_freq;
1279 wpa_s->reattach = 0;
1284 ssid = wpa_s->conf->ssid;
1287 ssid->scan_ssid) {
1289 ssid->ssid, ssid->ssid_len);
1291 ssid->ssid;
1293 ssid->ssid_len;
1309 ssid = ssid->next;
1313 start != wpa_s->conf->ssid)
1314 ssid = wpa_s->conf->ssid;
1317 if (wpa_s->scan_id_count &&
1318 wpa_s->last_scan_req == MANUAL_SCAN_REQ)
1321 for (tssid = wpa_s->conf->ssid;
1322 wpa_s->last_scan_req != MANUAL_SCAN_REQ && tssid;
1323 tssid = tssid->next) {
1327 tssid->scan_freq) &&
1330 tssid->scan_freq);
1346 if (!wpa_s->prev_scan_wildcard) {
1349 wpa_s->prev_scan_wildcard = 1;
1353 wpa_s->prev_scan_ssid = ssid;
1354 wpa_s->prev_scan_wildcard = 0;
1357 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1362 wpa_s->prev_scan_ssid = ssid;
1366 } else if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
1367 wpa_s->manual_scan_passive && params.num_ssids == 0) {
1369 } else if (wpa_s->conf->passive_scan) {
1373 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
1383 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
1384 wpa_s->manual_scan_only_new) {
1390 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ && params.freqs == NULL &&
1391 wpa_s->manual_scan_freqs) {
1393 params.freqs = wpa_s->manual_scan_freqs;
1394 wpa_s->manual_scan_freqs = NULL;
1397 if (params.freqs == NULL && wpa_s->select_network_scan_freqs) {
1400 params.freqs = wpa_s->select_network_scan_freqs;
1401 wpa_s->select_network_scan_freqs = NULL;
1404 if (params.freqs == NULL && wpa_s->next_scan_freqs) {
1407 params.freqs = wpa_s->next_scan_freqs;
1409 os_free(wpa_s->next_scan_freqs);
1410 wpa_s->next_scan_freqs = NULL;
1414 if (wpa_s->last_scan_req == INITIAL_SCAN_REQ &&
1415 wpa_s->conf->initial_freq_list && !params.freqs) {
1417 "Optimize scan based on conf->initial_freq_list");
1418 int_array_concat(¶ms.freqs, wpa_s->conf->initial_freq_list);
1419 } else if (wpa_s->conf->freq_list && !params.freqs) {
1421 "Optimize scan based on conf->freq_list");
1422 int_array_concat(¶ms.freqs, wpa_s->conf->freq_list);
1426 if (wpa_s->conf->scan_cur_freq && !params.freqs) {
1427 unsigned int num = wpa_s->num_multichan_concurrent;
1445 if (wpa_s->enable_oce & OCE_STA)
1450 wpa_s->conf, ¶ms.num_filter_ssids);
1457 if (wpa_s->p2p_in_provisioning || wpa_s->p2p_in_invitation ||
1458 (wpa_s->show_group_started && wpa_s->go_params)) {
1467 if ((wpa_s->mac_addr_rand_enable & MAC_ADDR_RAND_SCAN) &&
1468 wpa_s->wpa_state <= WPA_SCANNING)
1469 wpa_setup_mac_addr_rand_params(¶ms, wpa_s->mac_addr_scan);
1471 if (!is_zero_ether_addr(wpa_s->next_scan_bssid)) {
1474 params.bssid = wpa_s->next_scan_bssid;
1476 if (!wpa_s->next_scan_bssid_wildcard_ssid &&
1477 bss && bss->ssid_len && params.num_ssids == 1 &&
1479 params.ssids[0].ssid = bss->ssid;
1480 params.ssids[0].ssid_len = bss->ssid_len;
1485 wpa_ssid_txt(bss->ssid, bss->ssid_len));
1491 } else if (!is_zero_ether_addr(wpa_s->ml_probe_bssid)) {
1493 params.bssid = wpa_s->ml_probe_bssid;
1498 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
1499 wpa_s->manual_non_coloc_6ghz) {
1509 * If the driver does not support multi-channel concurrency and a
1517 if (wpa_s->scan_for_connection &&
1518 wpa_s->last_scan_req == NORMAL_SCAN_REQ &&
1519 !scan_params->freqs && !params.freqs &&
1521 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE &&
1523 unsigned int num = wpa_s->num_multichan_concurrent;
1534 if (num > 0 && num == wpa_s->num_multichan_concurrent) {
1544 (wpa_s->p2p_in_invitation || wpa_s->p2p_in_provisioning))
1550 if (ret && wpa_s->last_scan_req == MANUAL_SCAN_REQ && params.freqs &&
1551 !wpa_s->manual_scan_freqs) {
1553 wpa_s->manual_scan_freqs = params.freqs;
1564 if (wpa_s->scan_prev_wpa_state != wpa_s->wpa_state)
1566 wpa_s->scan_prev_wpa_state);
1568 wpa_s->scan_req = wpa_s->last_scan_req;
1571 wpa_s->scan_for_connection = 0;
1573 wpa_s->interworking_fast_assoc_tried = 0;
1575 wpa_s->next_scan_bssid_wildcard_ssid = 0;
1577 os_memset(wpa_s->next_scan_bssid, 0, ETH_ALEN);
1580 wpa_s->ml_probe_mld_id = -1;
1581 wpa_s->ml_probe_links = 0;
1582 os_memset(wpa_s->ml_probe_bssid, 0, sizeof(wpa_s->ml_probe_bssid));
1605 wpa_s->scan_interval = sec;
1610 * wpa_supplicant_req_scan - Schedule a scan for neighboring access points
1622 if (wpa_s->p2p_mgmt) {
1646 * wpa_supplicant_delayed_sched_scan - Request a delayed scheduled scan
1650 * Returns: 0 on success or -1 otherwise
1658 if (!wpa_s->sched_scan_supported)
1659 return -1;
1673 if (wpa_s->wpa_state != WPA_COMPLETED ||
1674 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SCHED_SCAN_RELATIVE_RSSI) ||
1675 wpa_s->srp.relative_rssi_set == 0)
1678 params->relative_rssi_set = 1;
1679 params->relative_rssi = wpa_s->srp.relative_rssi;
1681 if (wpa_s->srp.relative_adjust_rssi == 0)
1684 params->relative_adjust_band = wpa_s->srp.relative_adjust_band;
1685 params->relative_adjust_rssi = wpa_s->srp.relative_adjust_rssi;
1690 * wpa_supplicant_req_sched_scan - Start a periodic scheduled scan
1692 * Returns: 0 is sched_scan was started or -1 otherwise
1710 if (!wpa_s->sched_scan_supported)
1711 return -1;
1713 if (wpa_s->max_sched_scan_ssids > WPAS_MAX_SCAN_SSIDS)
1716 max_sched_scan_ssids = wpa_s->max_sched_scan_ssids;
1717 if (max_sched_scan_ssids < 1 || wpa_s->conf->disable_scan_offload)
1718 return -1;
1720 wpa_s->sched_scan_stop_req = 0;
1722 if (wpa_s->sched_scanning) {
1728 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1729 if (!wpas_network_disabled(wpa_s, ssid) && !ssid->scan_ssid) {
1733 ssid->ssid_len)
1738 ssid->key_mgmt == WPA_KEY_MGMT_WPS) {
1747 return -1;
1754 if (wpa_s->normal_scans < 3 &&
1755 (need_ssids <= wpa_s->max_scan_ssids ||
1756 wpa_s->max_scan_ssids >= (int) max_sched_scan_ssids)) {
1766 wpa_s->normal_scans);
1767 return -1;
1773 params.filter_ssids = os_calloc(wpa_s->max_match_sets,
1776 prev_state = wpa_s->wpa_state;
1777 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
1778 wpa_s->wpa_state == WPA_INACTIVE)
1781 if (wpa_s->autoscan_params != NULL) {
1782 scan_params = wpa_s->autoscan_params;
1787 ssid = wpa_s->conf->ssid;
1788 if (wpa_s->prev_sched_ssid) {
1790 if (ssid == wpa_s->prev_sched_ssid) {
1791 ssid = ssid->next;
1794 ssid = ssid->next;
1798 if (!ssid || !wpa_s->prev_sched_ssid) {
1800 wpa_s->sched_scan_timeout = max_sched_scan_ssids * 2;
1801 wpa_s->first_sched_scan = 1;
1802 ssid = wpa_s->conf->ssid;
1803 wpa_s->prev_sched_ssid = ssid;
1815 if (params.num_filter_ssids < wpa_s->max_match_sets &&
1816 params.filter_ssids && ssid->ssid && ssid->ssid_len) {
1818 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1820 ssid->ssid, ssid->ssid_len);
1822 ssid->ssid_len;
1824 } else if (params.filter_ssids && ssid->ssid && ssid->ssid_len)
1827 "filter for sched_scan - drop filter");
1833 if (ssid->scan_ssid && ssid->ssid && ssid->ssid_len) {
1838 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1840 ssid->ssid;
1842 ssid->ssid_len;
1845 wpa_s->prev_sched_ssid = ssid;
1847 ssid = ssid->next;
1850 !ssid->scan_ssid));
1856 wpa_s->prev_sched_ssid = ssid;
1857 ssid = ssid->next;
1871 if (wpa_s->conf->filter_rssi)
1872 params.filter_rssi = wpa_s->conf->filter_rssi;
1875 if (wpa_s->conf->freq_list && !params.freqs) {
1877 "Optimize scan based on conf->freq_list");
1878 int_array_concat(¶ms.freqs, wpa_s->conf->freq_list);
1882 if (wpa_s->enable_oce & OCE_STA)
1889 wpa_s->sched_scan_timed_out = 0;
1896 if (wpa_s->sched_scan_plans_num == 1 ||
1897 (wpa_s->sched_scan_plans_num && !ssid && wpa_s->first_sched_scan)) {
1898 params.sched_scan_plans = wpa_s->sched_scan_plans;
1899 params.sched_scan_plans_num = wpa_s->sched_scan_plans_num;
1900 } else if (wpa_s->sched_scan_plans_num > 1) {
1904 &wpa_s->sched_scan_plans[wpa_s->sched_scan_plans_num -
1908 if (wpa_s->conf->sched_scan_interval)
1909 scan_plan.interval = wpa_s->conf->sched_scan_interval;
1913 if (scan_plan.interval > wpa_s->max_sched_scan_plan_interval) {
1917 wpa_s->max_sched_scan_plan_interval);
1919 wpa_s->max_sched_scan_plan_interval;
1927 params.sched_scan_start_delay = wpa_s->conf->sched_scan_start_delay;
1929 if (ssid || !wpa_s->first_sched_scan) {
1934 wpa_s->sched_scan_timeout);
1943 if ((wpa_s->mac_addr_rand_enable & MAC_ADDR_RAND_SCHED_SCAN) &&
1944 wpa_s->wpa_state <= WPA_SCANNING)
1946 wpa_s->mac_addr_sched_scan);
1956 if (prev_state != wpa_s->wpa_state)
1962 if (ssid || !wpa_s->first_sched_scan) {
1963 wpa_s->sched_scan_timed_out = 0;
1964 eloop_register_timeout(wpa_s->sched_scan_timeout, 0,
1967 wpa_s->first_sched_scan = 0;
1968 wpa_s->sched_scan_timeout /= 2;
1970 if ((unsigned int) wpa_s->sched_scan_timeout <
1973 wpa_s->max_sched_scan_plan_interval) {
1975 wpa_s->sched_scan_timeout = max_sched_scan_ssids * 2;
1981 wpa_s->prev_sched_ssid = NULL;
1988 * wpa_supplicant_cancel_scan - Cancel a scheduled scan request
2002 * wpa_supplicant_cancel_delayed_sched_scan - Stop a delayed scheduled scan
2009 if (!wpa_s->sched_scan_supported)
2019 * wpa_supplicant_cancel_sched_scan - Stop running scheduled scans
2026 if (!wpa_s->sched_scanning)
2029 if (wpa_s->sched_scanning)
2030 wpa_s->sched_scan_stop_req = 1;
2039 * wpa_supplicant_notify_scanning - Indicate possible scan state change
2051 if (wpa_s->scanning != scanning) {
2052 wpa_s->scanning = scanning;
2081 * wpa_scan_get_ie - Fetch a specified information element from a scan result
2091 size_t ie_len = res->ie_len;
2093 /* Use the Beacon frame IEs if res->ie_len is not available */
2095 ie_len = res->beacon_ie_len;
2103 size_t ie_len = res->ie_len;
2105 /* Use the Beacon frame IEs if res->ie_len is not available */
2107 ie_len = res->beacon_ie_len;
2114 * wpa_scan_get_vendor_ie - Fetch vendor information element from a scan result
2130 for_each_element_id(elem, WLAN_EID_VENDOR_SPECIFIC, ies, res->ie_len) {
2131 if (elem->datalen >= 4 &&
2132 vendor_type == WPA_GET_BE32(elem->data))
2133 return &elem->id;
2141 * wpa_scan_get_vendor_ie_beacon - Fetch vendor information from a scan result
2158 if (res->beacon_ie_len == 0)
2162 ies += res->ie_len;
2165 res->beacon_ie_len) {
2166 if (elem->datalen >= 4 &&
2167 vendor_type == WPA_GET_BE32(elem->data))
2168 return &elem->id;
2176 * wpa_scan_get_vendor_ie_multi - Fetch vendor IE data from a scan result
2191 buf = wpabuf_alloc(res->ie_len);
2196 end = pos + res->ie_len;
2198 while (end - pos > 1) {
2203 if (len > end - pos - 2)
2208 wpabuf_put_data(buf, pos + 4, len - 4);
2240 * wpas_channel_width_tx_pwr - Calculate the max transmit power at the channel
2245 * Returns: The max transmit power at the channel width, TX_POWER_NO_CONSTRAINT
2271 if (elem->datalen < 1)
2275 * IEEE Std 802.11ax-2021, 9.4.2.161 (Transmit Power Envelope
2276 * element) defines Maximum Transmit Power Count (B0-B2),
2277 * Maximum Transmit Power Interpretation (B3-B5), and Maximum
2278 * Transmit Power Category (B6-B7).
2280 max_tx_pwr_count = elem->data[0] & 0x07;
2281 tx_pwr_intrpn = (elem->data[0] >> 3) & 0x07;
2282 client_type = (elem->data[0] >> 6) & 0x03;
2293 if (elem->datalen <= offs)
2295 tx_pwr = (signed char) elem->data[offs];
2298 * 8-bit 2s complement signed integer in the range -64
2308 if (elem->datalen < 2)
2311 tx_pwr = (signed char) elem->data[1];
2313 * Maximum Transmit PSD subfield is encoded as an 8-bit
2314 * 2s complement signed integer. -128 indicates that the
2320 if (tx_pwr == 127 || tx_pwr == -128)
2352 0 : (max_cw_tx_pwr - max_20mhz_tx_pwr);
2365 * 10*log10(N) - 10*log10(20) = 10*log10(N/20) = 3*log2(N/20)
2369 return snr + rssi_bump - noise_bump;
2395 return -1;
2398 if ((wa->caps & IEEE80211_CAP_PRIVACY) == 0 &&
2399 (wb->caps & IEEE80211_CAP_PRIVACY))
2401 if ((wa->caps & IEEE80211_CAP_PRIVACY) &&
2402 (wb->caps & IEEE80211_CAP_PRIVACY) == 0)
2403 return -1;
2405 if (wa->flags & wb->flags & WPA_SCAN_LEVEL_DBM) {
2411 ies_len = wa->ie_len ? wa->ie_len : wa->beacon_ie_len;
2413 ies_len, wa->max_cw,
2414 wa->snr);
2416 ies_len = wb->ie_len ? wb->ie_len : wb->beacon_ie_len;
2418 ies_len, wb->max_cw,
2419 wb->snr);
2424 snr_a = snr_a_full = wa->level;
2425 snr_b = snr_b_full = wb->level;
2429 * prefer SAE over PSK for mixed WPA3-Personal transition mode and
2430 * WPA2-Personal deployments */
2448 return -1;
2454 /* If SNR is close, decide by max rate or frequency band. For cases
2459 if (snr_a && snr_b && (abs(snr_b - snr_a) < 7 ||
2460 is_6ghz_freq(wa->freq) ||
2461 is_6ghz_freq(wb->freq))) {
2462 if (wa->est_throughput != wb->est_throughput)
2463 return (int) wb->est_throughput -
2464 (int) wa->est_throughput;
2466 if ((snr_a && snr_b && abs(snr_b - snr_a) < 5) ||
2467 (wa->qual && wb->qual && abs(wb->qual - wa->qual) < 10)) {
2468 if (is_6ghz_freq(wa->freq) ^ is_6ghz_freq(wb->freq))
2469 return is_6ghz_freq(wa->freq) ? -1 : 1;
2470 if (IS_5GHZ(wa->freq) ^ IS_5GHZ(wb->freq))
2471 return IS_5GHZ(wa->freq) ? -1 : 1;
2478 return wb->qual - wa->qual;
2479 return snr_b_full - snr_a_full;
2496 /* Optimization - check WPS IE existence before allocated memory and
2501 return -1;
2524 if (wb->level == wa->level)
2525 return wb->qual - wa->qual;
2526 return wb->level - wa->level;
2536 if (scan_res->res == NULL || scan_res->num == 0)
2541 for (i = 0; i < scan_res->num; i++) {
2542 struct wpa_scan_res *r = scan_res->res[i];
2553 if (r->flags & WPA_SCAN_LEVEL_DBM) {
2554 int noise_valid = !(r->flags & WPA_SCAN_NOISE_INVALID);
2558 MAC2STR(r->bssid),
2560 r->freq, r->qual,
2561 r->noise, noise_valid ? "" : "~", r->level,
2562 r->snr, r->snr >= GREAT_SNR ? "*" : "",
2563 r->flags,
2564 r->age, r->est_throughput);
2568 MAC2STR(r->bssid),
2570 r->freq, r->qual,
2571 r->noise, r->level, r->flags, r->age,
2572 r->est_throughput);
2575 if (r->ie_len)
2576 wpa_hexdump(MSG_EXCESSIVE, "IEs", pos, r->ie_len);
2577 pos += r->ie_len;
2578 if (r->beacon_ie_len)
2580 pos, r->beacon_ie_len);
2587 * wpa_supplicant_filter_bssid_match - Is the specified BSSID allowed
2600 if (wpa_s->bssid_filter == NULL)
2603 for (i = 0; i < wpa_s->bssid_filter_count; i++) {
2604 if (ether_addr_equal(wpa_s->bssid_filter + i * ETH_ALEN, bssid))
2617 if (wpa_s->bssid_filter == NULL)
2620 for (i = 0, j = 0; i < res->num; i++) {
2622 res->res[i]->bssid)) {
2623 res->res[j++] = res->res[i];
2625 os_free(res->res[i]);
2626 res->res[i] = NULL;
2630 if (res->num != j) {
2632 (int) (res->num - j));
2633 res->num = j;
2640 if (res->flags & WPA_SCAN_NOISE_INVALID) {
2641 res->noise = is_6ghz_freq(res->freq) ?
2643 (IS_5GHZ(res->freq) ?
2647 if (res->flags & WPA_SCAN_LEVEL_DBM) {
2648 res->snr = res->level - res->noise;
2652 res->snr = res->level;
2657 /* Minimum SNR required to achieve a certain bitrate. */
2660 unsigned int bitrate; /* in Mbps */
2677 { -1, 78000 } /* SNR > 29 */
2692 { -1, 180000 } /* SNR > 34 */
2707 { -1, 390000 } /* SNR > 37 */
2723 { -1, 780000 } /* SNR > 37 */
2745 { -1, 172100 } /* SNR > 42 */
2764 { -1, 344100 } /* SNR > 45 */
2783 { -1, 720600 } /* SNR > 48 */
2803 { -1, 1441200 } /* SNR > 51 */
2806 /* See IEEE P802.11be/D2.0, Table 36-86: EHT-MCSs for 4x996-tone RU, NSS,u = 1
2824 { -1, 2882400 } /* SNR > 54 */
2830 return rate0 + (snr - snr0) * (rate1 - rate0) / (snr1 - snr0);
2839 while ((entry->minsnr != -1) &&
2840 (snr >= entry->minsnr) &&
2841 (vht || entry - table <= vht_mcs))
2844 return entry->bitrate;
2845 prev = entry - 1;
2846 if (entry->minsnr == -1 || (!vht && entry - table > vht_mcs))
2847 return prev->bitrate;
2848 return interpolate_rate(snr, prev->minsnr, entry->minsnr, prev->bitrate,
2849 entry->bitrate);
2882 while (entry->minsnr != -1 && snr >= entry->minsnr &&
2883 (eht || entry - table <= EHT_MCS))
2887 prev = entry - 1;
2888 if (entry->minsnr == -1 || (!eht && entry - table > EHT_MCS))
2889 return prev->bitrate;
2890 return interpolate_rate(snr, prev->minsnr, entry->minsnr,
2891 prev->bitrate, entry->bitrate);
2951 hw_mode = get_mode_with_freq(wpa_s->hw.modes, wpa_s->hw.num_modes,
2954 if (hw_mode && hw_mode->ht_capab) {
2970 (hw_mode->ht_capab & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) {
2982 /* Determine VHT BSS bandwidth based on IEEE Std 802.11-2020,
2983 * Table 11-23 (VHT BSS bandwidth) */
2993 (cw == 3 && (seg1 > 0 && abs(seg1 - seg0) == 16)))
2996 ((seg1 > 0 && abs(seg1 - seg0) == 8) ||
2997 (seg1 > 0 && abs(seg1 - seg0) == 16)))
3001 if (hw_mode && hw_mode->vht_capab) {
3032 (hw_mode->vht_capab &
3046 if (hw_mode && hw_mode->he_capab[IEEE80211_MODE_INFRA].he_supported) {
3059 own_he = &hw_mode->he_capab[IEEE80211_MODE_INFRA];
3062 if (hw_mode->eht_capab[IEEE80211_MODE_INFRA].eht_supported) {
3078 cw = he->he_phy_capab_info[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] &
3079 own_he->phy_cap[HE_PHYCAP_CHANNEL_WIDTH_SET_IDX];
3130 (eht->phy_cap[EHT_PHYCAP_320MHZ_IN_6GHZ_SUPPORT_IDX] &
3150 int rate; /* max legacy rate in 500 kb/s units */
3151 int snr = res->snr;
3153 size_t ie_len = res->ie_len;
3155 if (res->est_throughput)
3162 ie_len = res->beacon_ie_len;
3163 res->est_throughput = wpas_get_est_tpt(wpa_s, ies, ie_len, rate, snr,
3164 res->freq, &res->max_cw);
3171 * wpa_supplicant_get_scan_results - Get scan results
3179 * the local BSS list wpa_s->bss. The caller is responsible for freeing the
3196 if (scan_res->fetch_time.sec == 0) {
3201 os_get_reltime(&scan_res->fetch_time);
3205 for (i = 0; i < scan_res->num; i++) {
3206 struct wpa_scan_res *scan_res_item = scan_res->res[i];
3220 if (scan_res->res) {
3221 qsort(scan_res->res, scan_res->num,
3226 if (wpa_s->ignore_post_flush_scan_res) {
3231 "Do not update BSS table based on pending post-FLUSH scan results");
3232 wpa_s->ignore_post_flush_scan_res = 0;
3237 for (i = 0; i < scan_res->num; i++)
3238 wpa_bss_update_scan_res(wpa_s, scan_res->res[i],
3239 &scan_res->fetch_time);
3247 * wpa_supplicant_update_scan_results - Update scan results from the driver
3250 * Returns: 0 on success, -1 on failure
3257 * steps in 4-way handshake).
3265 return -1;
3273 * scan_only_handler - Reports scan results
3278 wpa_dbg(wpa_s, MSG_DEBUG, "Scan-only results received");
3279 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
3280 wpa_s->manual_scan_use_id && wpa_s->own_scan_running) {
3282 wpa_s->manual_scan_id);
3283 wpa_s->manual_scan_use_id = 0;
3289 if (wpa_s->scan_work) {
3290 struct wpa_radio_work *work = wpa_s->scan_work;
3291 wpa_s->scan_work = NULL;
3295 if (wpa_s->wpa_state == WPA_SCANNING)
3296 wpa_supplicant_set_state(wpa_s, wpa_s->scan_prev_wpa_state);
3317 for (i = 0; i < src->num_ssids; i++) {
3318 if (src->ssids[i].ssid) {
3319 n = os_memdup(src->ssids[i].ssid,
3320 src->ssids[i].ssid_len);
3323 params->ssids[i].ssid = n;
3324 params->ssids[i].ssid_len = src->ssids[i].ssid_len;
3327 params->num_ssids = src->num_ssids;
3329 if (src->extra_ies) {
3330 n = os_memdup(src->extra_ies, src->extra_ies_len);
3333 params->extra_ies = n;
3334 params->extra_ies_len = src->extra_ies_len;
3337 if (src->freqs) {
3338 int len = int_array_len(src->freqs);
3339 params->freqs = os_memdup(src->freqs, (len + 1) * sizeof(int));
3340 if (params->freqs == NULL)
3344 if (src->filter_ssids) {
3345 params->filter_ssids = os_memdup(src->filter_ssids,
3346 sizeof(*params->filter_ssids) *
3347 src->num_filter_ssids);
3348 if (params->filter_ssids == NULL)
3350 params->num_filter_ssids = src->num_filter_ssids;
3353 params->filter_rssi = src->filter_rssi;
3354 params->p2p_probe = src->p2p_probe;
3355 params->only_new_results = src->only_new_results;
3356 params->low_priority = src->low_priority;
3357 params->duration = src->duration;
3358 params->duration_mandatory = src->duration_mandatory;
3359 params->oce_scan = src->oce_scan;
3360 params->link_id = src->link_id;
3362 if (src->sched_scan_plans_num > 0) {
3363 params->sched_scan_plans =
3364 os_memdup(src->sched_scan_plans,
3365 sizeof(*src->sched_scan_plans) *
3366 src->sched_scan_plans_num);
3367 if (!params->sched_scan_plans)
3370 params->sched_scan_plans_num = src->sched_scan_plans_num;
3373 if (src->mac_addr_rand &&
3374 wpa_setup_mac_addr_rand_params(params, src->mac_addr))
3377 if (src->bssid) {
3380 bssid = os_memdup(src->bssid, ETH_ALEN);
3383 params->bssid = bssid;
3386 params->relative_rssi_set = src->relative_rssi_set;
3387 params->relative_rssi = src->relative_rssi;
3388 params->relative_adjust_band = src->relative_adjust_band;
3389 params->relative_adjust_rssi = src->relative_adjust_rssi;
3390 params->p2p_include_6ghz = src->p2p_include_6ghz;
3391 params->non_coloc_6ghz = src->non_coloc_6ghz;
3392 params->min_probe_req_content = src->min_probe_req_content;
3408 for (i = 0; i < params->num_ssids; i++)
3409 os_free((u8 *) params->ssids[i].ssid);
3410 os_free((u8 *) params->extra_ies);
3411 os_free(params->freqs);
3412 os_free(params->filter_ssids);
3413 os_free(params->sched_scan_plans);
3416 * Note: params->mac_addr_mask points to same memory allocation and
3419 os_free((u8 *) params->mac_addr);
3421 os_free((u8 *) params->bssid);
3436 if (!wpa_s->sched_scan_supported)
3437 return -1;
3439 if (wpa_s->max_sched_scan_ssids > WPAS_MAX_SCAN_SSIDS)
3442 max_sched_scan_ssids = wpa_s->max_sched_scan_ssids;
3444 return -1;
3446 if (wpa_s->pno || wpa_s->pno_sched_pending)
3449 if ((wpa_s->wpa_state > WPA_SCANNING) &&
3450 (wpa_s->wpa_state < WPA_COMPLETED)) {
3452 return -EAGAIN;
3455 if (wpa_s->wpa_state == WPA_SCANNING) {
3457 if (wpa_s->sched_scanning) {
3461 wpa_s->pno_sched_pending = 1;
3466 if (wpa_s->sched_scan_stop_req) {
3469 wpa_s->pno_sched_pending = 1;
3476 ssid = wpa_s->conf->ssid;
3480 if (ssid->scan_ssid)
3483 ssid = ssid->next;
3488 return -1;
3502 if (num_match_ssid > wpa_s->max_match_sets) {
3503 num_match_ssid = wpa_s->max_match_sets;
3509 return -1;
3513 ssid = wpa_s->conf->pssid[prio];
3516 if (ssid->scan_ssid && params.num_ssids < num_ssid) {
3518 ssid->ssid;
3520 ssid->ssid_len;
3523 os_memcpy(params.filter_ssids[i].ssid, ssid->ssid,
3524 ssid->ssid_len);
3525 params.filter_ssids[i].ssid_len = ssid->ssid_len;
3531 if (ssid->pnext)
3532 ssid = ssid->pnext;
3533 else if (prio + 1 == wpa_s->conf->num_prio)
3536 ssid = wpa_s->conf->pssid[++prio];
3539 if (wpa_s->conf->filter_rssi)
3540 params.filter_rssi = wpa_s->conf->filter_rssi;
3542 if (wpa_s->sched_scan_plans_num) {
3543 params.sched_scan_plans = wpa_s->sched_scan_plans;
3544 params.sched_scan_plans_num = wpa_s->sched_scan_plans_num;
3547 if (wpa_s->conf->sched_scan_interval)
3548 scan_plan.interval = wpa_s->conf->sched_scan_interval;
3557 params.sched_scan_start_delay = wpa_s->conf->sched_scan_start_delay;
3559 if (params.freqs == NULL && wpa_s->manual_sched_scan_freqs) {
3561 params.freqs = wpa_s->manual_sched_scan_freqs;
3564 if ((wpa_s->mac_addr_rand_enable & MAC_ADDR_RAND_PNO) &&
3565 wpa_s->wpa_state <= WPA_SCANNING)
3566 wpa_setup_mac_addr_rand_params(¶ms, wpa_s->mac_addr_pno);
3574 wpa_s->pno = 1;
3585 if (!wpa_s->pno)
3589 wpa_s->sched_scan_stop_req = 1;
3591 wpa_s->pno = 0;
3592 wpa_s->pno_sched_pending = 0;
3594 if (wpa_s->wpa_state == WPA_SCANNING)
3605 wpa_s->mac_addr_rand_enable &= ~type;
3608 os_free(wpa_s->mac_addr_scan);
3609 wpa_s->mac_addr_scan = NULL;
3613 os_free(wpa_s->mac_addr_sched_scan);
3614 wpa_s->mac_addr_sched_scan = NULL;
3618 os_free(wpa_s->mac_addr_pno);
3619 wpa_s->mac_addr_pno = NULL;
3630 if ((wpa_s->mac_addr_rand_supported & type) != type ) {
3633 type, wpa_s->mac_addr_rand_supported);
3634 return -1;
3642 return -1;
3648 wpa_s->mac_addr_scan = tmp;
3650 wpa_s->mac_addr_sched_scan = tmp;
3652 wpa_s->mac_addr_pno = tmp;
3658 return -1;
3661 wpa_s->mac_addr_rand_enable |= type;
3671 if ((wpa_s->mac_addr_rand_enable & type) != type)
3672 return -1;
3675 to_copy = wpa_s->mac_addr_scan;
3677 to_copy = wpa_s->mac_addr_sched_scan;
3679 to_copy = wpa_s->mac_addr_pno;
3684 return -1;
3695 struct wpa_radio *radio = wpa_s->radio;
3697 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
3698 if (work->wpa_s != wpa_s || !work->started ||
3699 (os_strcmp(work->type, "scan") != 0 &&
3700 os_strcmp(work->type, "p2p-scan") != 0))
3703 return wpa_drv_abort_scan(wpa_s, wpa_s->curr_scan_cookie);
3706 wpa_dbg(wpa_s, MSG_DEBUG, "No ongoing scan/p2p-scan found to abort");
3707 return -1;
3718 return -1;
3722 os_free(wpa_s->sched_scan_plans);
3723 wpa_s->sched_scan_plans = NULL;
3724 wpa_s->sched_scan_plans_num = 0;
3740 ret = sscanf(token, "%u:%u", &scan_plan->interval,
3741 &scan_plan->iterations);
3742 if (ret <= 0 || ret > 2 || !scan_plan->interval) {
3748 if (scan_plan->interval > wpa_s->max_sched_scan_plan_interval) {
3751 num, scan_plan->interval,
3752 wpa_s->max_sched_scan_plan_interval);
3753 scan_plan->interval =
3754 wpa_s->max_sched_scan_plan_interval;
3758 scan_plan->iterations = 0;
3762 if (!scan_plan->iterations) {
3769 if (scan_plan->iterations >
3770 wpa_s->max_sched_scan_plan_iterations) {
3773 num, scan_plan->iterations,
3774 wpa_s->max_sched_scan_plan_iterations);
3775 scan_plan->iterations =
3776 wpa_s->max_sched_scan_plan_iterations;
3781 num, scan_plan->interval, scan_plan->iterations);
3789 if (cstr_token(cmd, " ", &context) || scan_plans[num - 1].iterations) {
3796 num, scan_plans[num - 1].interval);
3798 if (num > wpa_s->max_sched_scan_plans) {
3801 wpa_s->max_sched_scan_plans);
3804 wpa_s->max_sched_scan_plans - 1);
3805 os_memcpy(&scan_plans[wpa_s->max_sched_scan_plans - 1],
3806 &scan_plans[num - 1], sizeof(*scan_plans));
3807 num = wpa_s->max_sched_scan_plans;
3810 os_free(wpa_s->sched_scan_plans);
3811 wpa_s->sched_scan_plans = scan_plans;
3812 wpa_s->sched_scan_plans_num = num;
3819 return -1;
3824 * wpas_scan_reset_sched_scan - Reset sched_scan state
3833 wpa_s->normal_scans = 0;
3834 if (wpa_s->sched_scanning) {
3835 wpa_s->sched_scan_timed_out = 0;
3836 wpa_s->prev_sched_ssid = NULL;
3845 wpa_s->sched_scan_timed_out = 1;
3846 wpa_s->prev_sched_ssid = NULL;