[thirdparty/hostap.git] / wpa_supplicant / scan.c

/*
 * WPA Supplicant - Scanning
 * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#include "includes.h"

#include "common.h"
#include "eloop.h"
#include "config.h"
#include "wpa_supplicant_i.h"
#include "driver_i.h"
#include "mlme.h"
#include "wps_supplicant.h"
#include "notify.h"


static void wpa_supplicant_gen_assoc_event(struct wpa_supplicant *wpa_s)
{
	struct wpa_ssid *ssid;
	union wpa_event_data data;

	ssid = wpa_supplicant_get_ssid(wpa_s);
	if (ssid == NULL)
		return;

	if (wpa_s->current_ssid == NULL) {
		wpa_s->current_ssid = ssid;
		if (wpa_s->current_ssid != NULL)
			wpas_notify_network_changed(wpa_s);
	}
	wpa_supplicant_initiate_eapol(wpa_s);
	wpa_printf(MSG_DEBUG, "Already associated with a configured network - "
		   "generating associated event");
	os_memset(&data, 0, sizeof(data));
	wpa_supplicant_event(wpa_s, EVENT_ASSOC, &data);
}


#ifdef CONFIG_WPS
static int wpas_wps_in_use(struct wpa_config *conf,
			   enum wps_request_type *req_type)
{
	struct wpa_ssid *ssid;
	int wps = 0;

	for (ssid = conf->ssid; ssid; ssid = ssid->next) {
		if (!(ssid->key_mgmt & WPA_KEY_MGMT_WPS))
			continue;

		wps = 1;
		*req_type = wpas_wps_get_req_type(ssid);
		if (!ssid->eap.phase1)
			continue;

		if (os_strstr(ssid->eap.phase1, "pbc=1"))
			return 2;
	}

	return wps;
}
#endif /* CONFIG_WPS */


static int wpa_supplicant_enabled_networks(struct wpa_config *conf)
{
	struct wpa_ssid *ssid = conf->ssid;
	while (ssid) {
		if (!ssid->disabled)
			return 1;
		ssid = ssid->next;
	}
	return 0;
}


static void wpa_supplicant_assoc_try(struct wpa_supplicant *wpa_s,
				     struct wpa_ssid *ssid)
{
	while (ssid) {
		if (!ssid->disabled)
			break;
		ssid = ssid->next;
	}

	/* ap_scan=2 mode - try to associate with each SSID. */
	if (ssid == NULL) {
		wpa_printf(MSG_DEBUG, "wpa_supplicant_scan: Reached "
			   "end of scan list - go back to beginning");
		wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
		wpa_supplicant_req_scan(wpa_s, 0, 0);
		return;
	}
	if (ssid->next) {
		/* Continue from the next SSID on the next attempt. */
		wpa_s->prev_scan_ssid = ssid;
	} else {
		/* Start from the beginning of the SSID list. */
		wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
	}
	wpa_supplicant_associate(wpa_s, NULL, ssid);
}


static int int_array_len(const int *a)
{
	int i;
	for (i = 0; a && a[i]; i++)
		;
	return i;
}


static void int_array_concat(int **res, const int *a)
{
	int reslen, alen, i;
	int *n;

	reslen = int_array_len(*res);
	alen = int_array_len(a);

	n = os_realloc(*res, (reslen + alen + 1) * sizeof(int));
	if (n == NULL) {
		os_free(*res);
		*res = NULL;
	}
	for (i = 0; i <= alen; i++)
		n[reslen + i] = a[i];
	*res = n;
}


static int freq_cmp(const void *a, const void *b)
{
	int _a = *(int *) a;
	int _b = *(int *) b;

	if (_a == 0)
		return 1;
	if (_b == 0)
		return -1;
	return _a - _b;
}


static void int_array_sort_unique(int *a)
{
	int alen;
	int i, j;

	if (a == NULL)
		return;

	alen = int_array_len(a);
	qsort(a, alen, sizeof(int), freq_cmp);

	i = 0;
	j = 1;
	while (a[i] && a[j]) {
		if (a[i] == a[j]) {
			j++;
			continue;
		}
		a[++i] = a[j++];
	}
	if (a[i])
		i++;
	a[i] = 0;
}


static void wpa_supplicant_scan(void *eloop_ctx, void *timeout_ctx)
{
	struct wpa_supplicant *wpa_s = eloop_ctx;
	struct wpa_ssid *ssid;
	int scan_req = 0, ret;
	struct wpabuf *wps_ie = NULL;
	int wps = 0;
#ifdef CONFIG_WPS
	enum wps_request_type req_type = WPS_REQ_ENROLLEE_INFO;
#endif /* CONFIG_WPS */
	struct wpa_driver_scan_params params;
	size_t max_ssids;

	if (wpa_s->disconnected && !wpa_s->scan_req) {
		wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
		return;
	}

	if (!wpa_supplicant_enabled_networks(wpa_s->conf) &&
	    !wpa_s->scan_req) {
		wpa_printf(MSG_DEBUG, "No enabled networks - do not scan");
		wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
		return;
	}

	if (wpa_s->conf->ap_scan != 0 &&
	    (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)) {
		wpa_printf(MSG_DEBUG, "Using wired authentication - "
			   "overriding ap_scan configuration");
		wpa_s->conf->ap_scan = 0;
		wpas_notify_ap_scan_changed(wpa_s);
	}

	if (wpa_s->conf->ap_scan == 0) {
		wpa_supplicant_gen_assoc_event(wpa_s);
		return;
	}

	if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) ||
	    wpa_s->conf->ap_scan == 2)
		max_ssids = 1;
	else {
		max_ssids = wpa_s->max_scan_ssids;
		if (max_ssids > WPAS_MAX_SCAN_SSIDS)
			max_ssids = WPAS_MAX_SCAN_SSIDS;
	}

#ifdef CONFIG_WPS
	wps = wpas_wps_in_use(wpa_s->conf, &req_type);
#endif /* CONFIG_WPS */

	if (wpa_s->scan_res_tried == 0 && wpa_s->conf->ap_scan == 1 &&
	    !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) &&
	    wps != 2) {
		wpa_s->scan_res_tried++;
		wpa_printf(MSG_DEBUG, "Trying to get current scan results "
			   "first without requesting a new scan to speed up "
			   "initial association");
		wpa_supplicant_event(wpa_s, EVENT_SCAN_RESULTS, NULL);
		return;
	}

	scan_req = wpa_s->scan_req;
	wpa_s->scan_req = 0;

	os_memset(&params, 0, sizeof(params));

	if (wpa_s->wpa_state == WPA_DISCONNECTED ||
	    wpa_s->wpa_state == WPA_INACTIVE)
		wpa_supplicant_set_state(wpa_s, WPA_SCANNING);

	/* Find the starting point from which to continue scanning */
	ssid = wpa_s->conf->ssid;
	if (wpa_s->prev_scan_ssid != WILDCARD_SSID_SCAN) {
		while (ssid) {
			if (ssid == wpa_s->prev_scan_ssid) {
				ssid = ssid->next;
				break;
			}
			ssid = ssid->next;
		}
	}

	if (scan_req != 2 && wpa_s->conf->ap_scan == 2) {
		wpa_supplicant_assoc_try(wpa_s, ssid);
		return;
	} else if (wpa_s->conf->ap_scan == 2) {
		/*
		 * User-initiated scan request in ap_scan == 2; scan with
		 * wildcard SSID.
		 */
		ssid = NULL;
	} else {
		struct wpa_ssid *start = ssid;
		int freqs_set = 0;
		if (ssid == NULL && max_ssids > 1)
			ssid = wpa_s->conf->ssid;
		while (ssid) {
			if (!ssid->disabled && ssid->scan_ssid) {
				wpa_hexdump_ascii(MSG_DEBUG, "Scan SSID",
						  ssid->ssid, ssid->ssid_len);
				params.ssids[params.num_ssids].ssid =
					ssid->ssid;
				params.ssids[params.num_ssids].ssid_len =
					ssid->ssid_len;
				params.num_ssids++;
				if (params.num_ssids + 1 >= max_ssids)
					break;
			}
			ssid = ssid->next;
			if (ssid == start)
				break;
			if (ssid == NULL && max_ssids > 1 &&
			    start != wpa_s->conf->ssid)
				ssid = wpa_s->conf->ssid;
		}

		for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
			if (ssid->disabled)
				continue;
			if ((params.freqs || !freqs_set) && ssid->scan_freq) {
				int_array_concat(&params.freqs,
						 ssid->scan_freq);
			} else {
				os_free(params.freqs);
				params.freqs = NULL;
			}
			freqs_set = 1;
		}
		int_array_sort_unique(params.freqs);
	}

	if (ssid) {
		wpa_s->prev_scan_ssid = ssid;
		if (max_ssids > 1) {
			wpa_printf(MSG_DEBUG, "Include wildcard SSID in the "
				   "scan request");
			params.num_ssids++;
		}
		wpa_printf(MSG_DEBUG, "Starting AP scan for specific SSID(s)");
	} else {
		wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
		params.num_ssids++;
		wpa_printf(MSG_DEBUG, "Starting AP scan for wildcard SSID");
	}

#ifdef CONFIG_WPS
	if (wps) {
		wps_ie = wps_build_probe_req_ie(wps == 2, &wpa_s->wps->dev,
						wpa_s->wps->uuid, req_type);
		if (wps_ie) {
			params.extra_ies = wpabuf_head(wps_ie);
			params.extra_ies_len = wpabuf_len(wps_ie);
		}
	}
#endif /* CONFIG_WPS */

	wpa_supplicant_notify_scanning(wpa_s, 1);

	if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
		ieee80211_sta_set_probe_req_ie(wpa_s, params.extra_ies,
					       params.extra_ies_len);
		ret = ieee80211_sta_req_scan(wpa_s, params.ssids[0].ssid,
					     params.ssids[0].ssid_len);
	} else {
		wpa_drv_set_probe_req_ie(wpa_s, params.extra_ies,
					 params.extra_ies_len);
		ret = wpa_drv_scan(wpa_s, &params);
	}

	wpabuf_free(wps_ie);
	os_free(params.freqs);

	if (ret) {
		wpa_printf(MSG_WARNING, "Failed to initiate AP scan.");
		wpa_supplicant_notify_scanning(wpa_s, 0);
		wpas_notify_scan_done(wpa_s, 0);
		wpa_supplicant_req_scan(wpa_s, 10, 0);
	} else
		wpa_s->scan_runs++;
}


/**
 * wpa_supplicant_req_scan - Schedule a scan for neighboring access points
 * @wpa_s: Pointer to wpa_supplicant data
 * @sec: Number of seconds after which to scan
 * @usec: Number of microseconds after which to scan
 *
 * This function is used to schedule a scan for neighboring access points after
 * the specified time.
 */
void wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec)
{
	/* If there's at least one network that should be specifically scanned
	 * then don't cancel the scan and reschedule.  Some drivers do
	 * background scanning which generates frequent scan results, and that
	 * causes the specific SSID scan to get continually pushed back and
	 * never happen, which causes hidden APs to never get probe-scanned.
	 */
	if (eloop_is_timeout_registered(wpa_supplicant_scan, wpa_s, NULL) &&
	    wpa_s->conf->ap_scan == 1) {
		struct wpa_ssid *ssid = wpa_s->conf->ssid;

		while (ssid) {
			if (!ssid->disabled && ssid->scan_ssid)
				break;
			ssid = ssid->next;
		}
		if (ssid) {
			wpa_msg(wpa_s, MSG_DEBUG, "Not rescheduling scan to "
			        "ensure that specific SSID scans occur");
			return;
		}
	}

	wpa_msg(wpa_s, MSG_DEBUG, "Setting scan request: %d sec %d usec",
		sec, usec);
	eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
	eloop_register_timeout(sec, usec, wpa_supplicant_scan, wpa_s, NULL);
}


/**
 * wpa_supplicant_cancel_scan - Cancel a scheduled scan request
 * @wpa_s: Pointer to wpa_supplicant data
 *
 * This function is used to cancel a scan request scheduled with
 * wpa_supplicant_req_scan().
 */
void wpa_supplicant_cancel_scan(struct wpa_supplicant *wpa_s)
{
	wpa_msg(wpa_s, MSG_DEBUG, "Cancelling scan request");
	eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
}


void wpa_supplicant_notify_scanning(struct wpa_supplicant *wpa_s,
				    int scanning)
{
	if (wpa_s->scanning != scanning) {
		wpa_s->scanning = scanning;
		wpas_notify_scanning(wpa_s);
	}
}
Commit	Line	Data
6fc6879b JM	1	/*
	2	* WPA Supplicant - Scanning
	3	* Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	* Alternatively, this software may be distributed under the terms of BSD
	10	* license.
	11	*
	12	* See README and COPYING for more details.
	13	*/
	14
	15	#include "includes.h"
	16
	17	#include "common.h"
	18	#include "eloop.h"
	19	#include "config.h"
	20	#include "wpa_supplicant_i.h"
2d5b792d	21	#include "driver_i.h"
6fc6879b	22	#include "mlme.h"
b01c18a8	23	#include "wps_supplicant.h"
8bac466b	24	#include "notify.h"
6fc6879b JM	25
	26
	27	static void wpa_supplicant_gen_assoc_event(struct wpa_supplicant *wpa_s)
	28	{
	29	struct wpa_ssid *ssid;
	30	union wpa_event_data data;
	31
	32	ssid = wpa_supplicant_get_ssid(wpa_s);
	33	if (ssid == NULL)
	34	return;
	35
8bac466b	36	if (wpa_s->current_ssid == NULL) {
6fc6879b	37	wpa_s->current_ssid = ssid;
8bac466b JM	38	if (wpa_s->current_ssid != NULL)
	39	wpas_notify_network_changed(wpa_s);
	40	}
6fc6879b JM	41	wpa_supplicant_initiate_eapol(wpa_s);
	42	wpa_printf(MSG_DEBUG, "Already associated with a configured network - "
	43	"generating associated event");
	44	os_memset(&data, 0, sizeof(data));
	45	wpa_supplicant_event(wpa_s, EVENT_ASSOC, &data);
	46	}
	47
	48
ad08c363	49	#ifdef CONFIG_WPS
f90c86d4 JM	50	static int wpas_wps_in_use(struct wpa_config *conf,
f90c86d4 JM	51	enum wps_request_type *req_type)
ad08c363 JM	52	{
	53	struct wpa_ssid *ssid;
	54	int wps = 0;
ad08c363 JM	55
	56	for (ssid = conf->ssid; ssid; ssid = ssid->next) {
	57	if (!(ssid->key_mgmt & WPA_KEY_MGMT_WPS))
	58	continue;
	59
	60	wps = 1;
b01c18a8	61	*req_type = wpas_wps_get_req_type(ssid);
ad08c363 JM	62	if (!ssid->eap.phase1)
	63	continue;
	64
ad08c363 JM	65	if (os_strstr(ssid->eap.phase1, "pbc=1"))
	66	return 2;
	67	}
	68
	69	return wps;
	70	}
	71	#endif /* CONFIG_WPS */
	72
e76baaac JM	73
	74	static int wpa_supplicant_enabled_networks(struct wpa_config *conf)
	75	{
	76	struct wpa_ssid *ssid = conf->ssid;
	77	while (ssid) {
	78	if (!ssid->disabled)
	79	return 1;
	80	ssid = ssid->next;
	81	}
	82	return 0;
	83	}
	84
	85
	86	static void wpa_supplicant_assoc_try(struct wpa_supplicant *wpa_s,
	87	struct wpa_ssid *ssid)
	88	{
	89	while (ssid) {
	90	if (!ssid->disabled)
	91	break;
	92	ssid = ssid->next;
	93	}
	94
	95	/* ap_scan=2 mode - try to associate with each SSID. */
	96	if (ssid == NULL) {
	97	wpa_printf(MSG_DEBUG, "wpa_supplicant_scan: Reached "
	98	"end of scan list - go back to beginning");
ba2a573c	99	wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
e76baaac JM	100	wpa_supplicant_req_scan(wpa_s, 0, 0);
	101	return;
	102	}
	103	if (ssid->next) {
	104	/* Continue from the next SSID on the next attempt. */
	105	wpa_s->prev_scan_ssid = ssid;
	106	} else {
	107	/* Start from the beginning of the SSID list. */
ba2a573c	108	wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
e76baaac JM	109	}
	110	wpa_supplicant_associate(wpa_s, NULL, ssid);
	111	}
	112
	113
d3a98225 JM	114	static int int_array_len(const int *a)
	115	{
	116	int i;
	117	for (i = 0; a && a[i]; i++)
	118	;
	119	return i;
	120	}
	121
	122
	123	static void int_array_concat(int *res, const int a)
	124	{
	125	int reslen, alen, i;
	126	int *n;
	127
	128	reslen = int_array_len(*res);
	129	alen = int_array_len(a);
	130
	131	n = os_realloc(res, (reslen + alen + 1) sizeof(int));
	132	if (n == NULL) {
	133	os_free(*res);
	134	*res = NULL;
	135	}
	136	for (i = 0; i <= alen; i++)
	137	n[reslen + i] = a[i];
	138	*res = n;
	139	}
	140
	141
	142	static int freq_cmp(const void a, const void b)
	143	{
	144	int _a = (int ) a;
	145	int _b = (int ) b;
	146
	147	if (_a == 0)
	148	return 1;
	149	if (_b == 0)
	150	return -1;
	151	return _a - _b;
	152	}
	153
	154
	155	static void int_array_sort_unique(int *a)
	156	{
	157	int alen;
	158	int i, j;
	159
	160	if (a == NULL)
	161	return;
	162
	163	alen = int_array_len(a);
	164	qsort(a, alen, sizeof(int), freq_cmp);
	165
	166	i = 0;
	167	j = 1;
	168	while (a[i] && a[j]) {
	169	if (a[i] == a[j]) {
	170	j++;
	171	continue;
	172	}
	173	a[++i] = a[j++];
	174	}
	175	if (a[i])
	176	i++;
	177	a[i] = 0;
178	}
179
180
6fc6879b JM	181	static void wpa_supplicant_scan(void eloop_ctx, void timeout_ctx)
	182	{
	183	struct wpa_supplicant *wpa_s = eloop_ctx;
	184	struct wpa_ssid *ssid;
e76baaac	185	int scan_req = 0, ret;
ad08c363	186	struct wpabuf *wps_ie = NULL;
ad08c363	187	int wps = 0;
b01c18a8	188	#ifdef CONFIG_WPS
f90c86d4	189	enum wps_request_type req_type = WPS_REQ_ENROLLEE_INFO;
b01c18a8	190	#endif /* CONFIG_WPS */
e76baaac JM	191	struct wpa_driver_scan_params params;
e76baaac JM	192	size_t max_ssids;
6fc6879b	193
3180d7a2 SO	194	if (wpa_s->disconnected && !wpa_s->scan_req) {
3180d7a2 SO	195	wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
6fc6879b	196	return;
3180d7a2	197	}
6fc6879b	198
e76baaac JM	199	if (!wpa_supplicant_enabled_networks(wpa_s->conf) &&
e76baaac JM	200	!wpa_s->scan_req) {
6fc6879b JM	201	wpa_printf(MSG_DEBUG, "No enabled networks - do not scan");
	202	wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
	203	return;
	204	}
6fc6879b	205
c2a04078 JM	206	if (wpa_s->conf->ap_scan != 0 &&
c2a04078 JM	207	(wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)) {
e519314e JW	208	wpa_printf(MSG_DEBUG, "Using wired authentication - "
e519314e JW	209	"overriding ap_scan configuration");
6fc6879b	210	wpa_s->conf->ap_scan = 0;
8bac466b	211	wpas_notify_ap_scan_changed(wpa_s);
6fc6879b JM	212	}
	213
	214	if (wpa_s->conf->ap_scan == 0) {
	215	wpa_supplicant_gen_assoc_event(wpa_s);
	216	return;
	217	}
	218
c2a04078 JM	219	if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) \|\|
c2a04078 JM	220	wpa_s->conf->ap_scan == 2)
e76baaac JM	221	max_ssids = 1;
	222	else {
	223	max_ssids = wpa_s->max_scan_ssids;
	224	if (max_ssids > WPAS_MAX_SCAN_SSIDS)
	225	max_ssids = WPAS_MAX_SCAN_SSIDS;
	226	}
	227
	228	#ifdef CONFIG_WPS
	229	wps = wpas_wps_in_use(wpa_s->conf, &req_type);
	230	#endif /* CONFIG_WPS */
	231
	232	if (wpa_s->scan_res_tried == 0 && wpa_s->conf->ap_scan == 1 &&
c2a04078 JM	233	!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) &&
c2a04078 JM	234	wps != 2) {
e76baaac JM	235	wpa_s->scan_res_tried++;
	236	wpa_printf(MSG_DEBUG, "Trying to get current scan results "
	237	"first without requesting a new scan to speed up "
	238	"initial association");
	239	wpa_supplicant_event(wpa_s, EVENT_SCAN_RESULTS, NULL);
	240	return;
	241	}
	242
	243	scan_req = wpa_s->scan_req;
	244	wpa_s->scan_req = 0;
	245
	246	os_memset(&params, 0, sizeof(params));
	247
6fc6879b JM	248	if (wpa_s->wpa_state == WPA_DISCONNECTED \|\|
	249	wpa_s->wpa_state == WPA_INACTIVE)
	250	wpa_supplicant_set_state(wpa_s, WPA_SCANNING);
	251
e76baaac	252	/* Find the starting point from which to continue scanning */
6fc6879b	253	ssid = wpa_s->conf->ssid;
ba2a573c	254	if (wpa_s->prev_scan_ssid != WILDCARD_SSID_SCAN) {
6fc6879b JM	255	while (ssid) {
	256	if (ssid == wpa_s->prev_scan_ssid) {
	257	ssid = ssid->next;
	258	break;
	259	}
	260	ssid = ssid->next;
	261	}
	262	}
6fc6879b JM	263
6fc6879b JM	264	if (scan_req != 2 && wpa_s->conf->ap_scan == 2) {
e76baaac JM	265	wpa_supplicant_assoc_try(wpa_s, ssid);
	266	return;
	267	} else if (wpa_s->conf->ap_scan == 2) {
6fc6879b	268	/*
ba2a573c JM	269	* User-initiated scan request in ap_scan == 2; scan with
ba2a573c JM	270	* wildcard SSID.
6fc6879b	271	*/
e76baaac JM	272	ssid = NULL;
	273	} else {
	274	struct wpa_ssid *start = ssid;
d3a98225	275	int freqs_set = 0;
e76baaac JM	276	if (ssid == NULL && max_ssids > 1)
	277	ssid = wpa_s->conf->ssid;
	278	while (ssid) {
	279	if (!ssid->disabled && ssid->scan_ssid) {
	280	wpa_hexdump_ascii(MSG_DEBUG, "Scan SSID",
	281	ssid->ssid, ssid->ssid_len);
	282	params.ssids[params.num_ssids].ssid =
	283	ssid->ssid;
	284	params.ssids[params.num_ssids].ssid_len =
	285	ssid->ssid_len;
	286	params.num_ssids++;
	287	if (params.num_ssids + 1 >= max_ssids)
	288	break;
	289	}
	290	ssid = ssid->next;
	291	if (ssid == start)
	292	break;
	293	if (ssid == NULL && max_ssids > 1 &&
	294	start != wpa_s->conf->ssid)
	295	ssid = wpa_s->conf->ssid;
6fc6879b	296	}
d3a98225 JM	297
	298	for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
	299	if (ssid->disabled)
	300	continue;
	301	if ((params.freqs \|\| !freqs_set) && ssid->scan_freq) {
	302	int_array_concat(&params.freqs,
	303	ssid->scan_freq);
	304	} else {
	305	os_free(params.freqs);
	306	params.freqs = NULL;
	307	}
	308	freqs_set = 1;
	309	}
	310	int_array_sort_unique(params.freqs);
6fc6879b JM	311	}
6fc6879b JM	312
6fc6879b	313	if (ssid) {
6fc6879b	314	wpa_s->prev_scan_ssid = ssid;
e76baaac	315	if (max_ssids > 1) {
ba2a573c	316	wpa_printf(MSG_DEBUG, "Include wildcard SSID in the "
e76baaac	317	"scan request");
ba2a573c	318	params.num_ssids++;
e76baaac JM	319	}
	320	wpa_printf(MSG_DEBUG, "Starting AP scan for specific SSID(s)");
	321	} else {
ba2a573c	322	wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
e76baaac	323	params.num_ssids++;
ba2a573c	324	wpa_printf(MSG_DEBUG, "Starting AP scan for wildcard SSID");
6fc6879b JM	325	}
6fc6879b JM	326
ad08c363 JM	327	#ifdef CONFIG_WPS
ad08c363 JM	328	if (wps) {
c0d041d9	329	wps_ie = wps_build_probe_req_ie(wps == 2, &wpa_s->wps->dev,
79da74a2	330	wpa_s->wps->uuid, req_type);
ad08c363	331	if (wps_ie) {
e76baaac JM	332	params.extra_ies = wpabuf_head(wps_ie);
e76baaac JM	333	params.extra_ies_len = wpabuf_len(wps_ie);
ad08c363 JM	334	}
	335	}
	336	#endif /* CONFIG_WPS */
	337
cb8564b1 DW	338	wpa_supplicant_notify_scanning(wpa_s, 1);
cb8564b1 DW	339
c2a04078	340	if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME) {
e76baaac JM	341	ieee80211_sta_set_probe_req_ie(wpa_s, params.extra_ies,
	342	params.extra_ies_len);
	343	ret = ieee80211_sta_req_scan(wpa_s, params.ssids[0].ssid,
	344	params.ssids[0].ssid_len);
6fc6879b	345	} else {
e76baaac JM	346	wpa_drv_set_probe_req_ie(wpa_s, params.extra_ies,
e76baaac JM	347	params.extra_ies_len);
fc2b7ed5	348	ret = wpa_drv_scan(wpa_s, &params);
6fc6879b JM	349	}
6fc6879b JM	350
ad08c363	351	wpabuf_free(wps_ie);
d3a98225	352	os_free(params.freqs);
ad08c363	353
6fc6879b JM	354	if (ret) {
6fc6879b JM	355	wpa_printf(MSG_WARNING, "Failed to initiate AP scan.");
cb8564b1	356	wpa_supplicant_notify_scanning(wpa_s, 0);
8bac466b	357	wpas_notify_scan_done(wpa_s, 0);
6fc6879b	358	wpa_supplicant_req_scan(wpa_s, 10, 0);
a6099152 JM	359	} else
a6099152 JM	360	wpa_s->scan_runs++;
6fc6879b JM	361	}
	362
	363
	364	/**
	365	* wpa_supplicant_req_scan - Schedule a scan for neighboring access points
	366	* @wpa_s: Pointer to wpa_supplicant data
	367	* @sec: Number of seconds after which to scan
	368	* @usec: Number of microseconds after which to scan
	369	*
	370	* This function is used to schedule a scan for neighboring access points after
	371	* the specified time.
	372	*/
	373	void wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec)
	374	{
7e148849 DW	375	/* If there's at least one network that should be specifically scanned
	376	* then don't cancel the scan and reschedule. Some drivers do
	377	* background scanning which generates frequent scan results, and that
	378	* causes the specific SSID scan to get continually pushed back and
	379	* never happen, which causes hidden APs to never get probe-scanned.
	380	*/
	381	if (eloop_is_timeout_registered(wpa_supplicant_scan, wpa_s, NULL) &&
	382	wpa_s->conf->ap_scan == 1) {
	383	struct wpa_ssid *ssid = wpa_s->conf->ssid;
	384
	385	while (ssid) {
	386	if (!ssid->disabled && ssid->scan_ssid)
	387	break;
	388	ssid = ssid->next;
	389	}
	390	if (ssid) {
	391	wpa_msg(wpa_s, MSG_DEBUG, "Not rescheduling scan to "
	392	"ensure that specific SSID scans occur");
	393	return;
	394	}
	395	}
	396
6fc6879b JM	397	wpa_msg(wpa_s, MSG_DEBUG, "Setting scan request: %d sec %d usec",
	398	sec, usec);
	399	eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
	400	eloop_register_timeout(sec, usec, wpa_supplicant_scan, wpa_s, NULL);
	401	}
	402
	403
	404	/**
	405	* wpa_supplicant_cancel_scan - Cancel a scheduled scan request
	406	* @wpa_s: Pointer to wpa_supplicant data
	407	*
	408	* This function is used to cancel a scan request scheduled with
	409	* wpa_supplicant_req_scan().
	410	*/
	411	void wpa_supplicant_cancel_scan(struct wpa_supplicant *wpa_s)
	412	{
	413	wpa_msg(wpa_s, MSG_DEBUG, "Cancelling scan request");
	414	eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
	415	}
cb8564b1 DW	416
	417
	418	void wpa_supplicant_notify_scanning(struct wpa_supplicant *wpa_s,
	419	int scanning)
	420	{
	421	if (wpa_s->scanning != scanning) {
	422	wpa_s->scanning = scanning;
8bac466b	423	wpas_notify_scanning(wpa_s);
cb8564b1 DW	424	}
	425	}
	426