自学教程：C++ wpa_ssid_txt函数代码示例

/* Format one result on one text line into a buffer. */static int wpa_supplicant_ctrl_iface_scan_result(	const struct wpa_scan_res *res, char *buf, size_t buflen){	char *pos, *end;	int ret;	const u8 *ie, *ie2;	pos = buf;	end = buf + buflen;	ret = os_snprintf(pos, end - pos, MACSTR "/t%d/t%d/t",			  MAC2STR(res->bssid), res->freq, res->level);	if (ret < 0 || ret >= end - pos)		return -1;	pos += ret;	ie = wpa_scan_get_vendor_ie(res, WPA_IE_VENDOR_TYPE);	if (ie)		pos = wpa_supplicant_ie_txt(pos, end, "WPA", ie, 2 + ie[1]);	ie2 = wpa_scan_get_ie(res, WLAN_EID_RSN);	if (ie2)		pos = wpa_supplicant_ie_txt(pos, end, "WPA2", ie2, 2 + ie2[1]);	pos = wpa_supplicant_wps_ie_txt(pos, end, res);	if (!ie && !ie2 && res->caps & IEEE80211_CAP_PRIVACY) {		ret = os_snprintf(pos, end - pos, "[WEP]");		if (ret < 0 || ret >= end - pos)			return -1;		pos += ret;	}    /* Just to make the fields line up nicely when printed */	if (!ie && !ie2) {		ret = os_snprintf(pos, end - pos, "/t");		if (ret < 0 || ret >= end - pos)			return -1;		pos += ret;	}	ie = wpa_scan_get_ie(res, WLAN_EID_SSID);	if (res->caps & IEEE80211_CAP_IBSS)		ret = os_snprintf(pos, end - pos, "/t%s%s", "(*)",                          wpa_ssid_txt(ie + 2, ie[1]));	else            ret = os_snprintf(pos, end - pos, "/t%s",                              ie ? wpa_ssid_txt(ie + 2, ie[1]) : "");	if (ret < 0 || ret >= end - pos)		return -1;	pos += ret;	ret = os_snprintf(pos, end - pos, "/n");	if (ret < 0 || ret >= end - pos)		return -1;	pos += ret;	return pos - buf;}

static struct wpa_bss *wpa_supplicant_select_bss(struct wpa_supplicant *wpa_s,			  struct wpa_scan_results *scan_res,			  struct wpa_ssid *group,			  struct wpa_ssid **selected_ssid){	size_t i;	wpa_printf(MSG_DEBUG, "Selecting BSS from priority group %d",		   group->priority);	for (i = 0; i < scan_res->num; i++) {		struct wpa_scan_res *bss = scan_res->res[i];		const u8 *ie, *ssid;		u8 ssid_len;		*selected_ssid = wpa_scan_res_match(wpa_s, i, bss, group);		if (!*selected_ssid)			continue;		ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);		ssid = ie ? ie + 2 : (u8 *) "";		ssid_len = ie ? ie[1] : 0;		wpa_printf(MSG_DEBUG, "   selected BSS " MACSTR " ssid='%s'",			   MAC2STR(bss->bssid), wpa_ssid_txt(ssid, ssid_len));		return wpa_bss_get(wpa_s, bss->bssid, ssid, ssid_len);	}	return NULL;}

static void wpa_bss_remove(struct wpa_supplicant *wpa_s, struct wpa_bss *bss){	dl_list_del(&bss->list);	dl_list_del(&bss->list_id);	wpa_s->num_bss--;	wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Remove id %u BSSID " MACSTR		" SSID '%s'", bss->id, MAC2STR(bss->bssid),		wpa_ssid_txt(bss->ssid, bss->ssid_len));	wpas_notify_bss_removed(wpa_s, bss->bssid, bss->id);#ifdef CONFIG_INTERWORKING	wpabuf_free(bss->anqp_venue_name);	wpabuf_free(bss->anqp_network_auth_type);	wpabuf_free(bss->anqp_roaming_consortium);	wpabuf_free(bss->anqp_ip_addr_type_availability);	wpabuf_free(bss->anqp_nai_realm);	wpabuf_free(bss->anqp_3gpp);	wpabuf_free(bss->anqp_domain_name);#endif /* CONFIG_INTERWORKING */#ifdef CONFIG_HS20	wpabuf_free(bss->hs20_operator_friendly_name);	wpabuf_free(bss->hs20_wan_metrics);	wpabuf_free(bss->hs20_connection_capability);	wpabuf_free(bss->hs20_operating_class);#endif /* CONFIG_HS20 */	os_free(bss);}

void wpas_notify_state_changed(struct wpa_supplicant *wpa_s,			       enum wpa_states new_state,			       enum wpa_states old_state){	/* notify the old DBus API */	wpa_supplicant_dbus_notify_state_change(wpa_s, new_state,						old_state);	/* notify the new DBus API */	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_STATE);#ifdef CONFIG_P2P	if (new_state == WPA_COMPLETED)		wpas_p2p_notif_connected(wpa_s);	else if (old_state >= WPA_ASSOCIATED && new_state < WPA_ASSOCIATED)		wpas_p2p_notif_disconnected(wpa_s);#endif /* CONFIG_P2P */	sme_state_changed(wpa_s);#ifdef ANDROID	wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_STATE_CHANGE		     "id=%d state=%d BSSID=" MACSTR " SSID=%s",		     wpa_s->current_ssid ? wpa_s->current_ssid->id : -1,		     new_state,		     MAC2STR(wpa_s->bssid),		     wpa_s->current_ssid && wpa_s->current_ssid->ssid ?		     wpa_ssid_txt(wpa_s->current_ssid->ssid,				  wpa_s->current_ssid->ssid_len) : "");#endif /* ANDROID */}

static void wpa_bss_remove(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,                           const char *reason){    if (wpa_s->last_scan_res) {        unsigned int i;        for (i = 0; i < wpa_s->last_scan_res_used; i++) {            if (wpa_s->last_scan_res[i] == bss) {                os_memmove(&wpa_s->last_scan_res[i],                           &wpa_s->last_scan_res[i + 1],                           (wpa_s->last_scan_res_used - i - 1)                           * sizeof(struct wpa_bss *));                wpa_s->last_scan_res_used--;                break;            }        }    }    wpa_bss_update_pending_connect(wpa_s, bss, NULL);    dl_list_del(&bss->list);    dl_list_del(&bss->list_id);    wpa_s->num_bss--;    wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Remove id %u BSSID " MACSTR            " SSID '%s' due to %s", bss->id, MAC2STR(bss->bssid),            wpa_ssid_txt(bss->ssid, bss->ssid_len), reason);    wpas_notify_bss_removed(wpa_s, bss->bssid, bss->id);    wpa_bss_anqp_free(bss->anqp);    os_free(bss);}

static void wpa_bss_add(struct wpa_supplicant *wpa_s,			const u8 *ssid, size_t ssid_len,			struct wpa_scan_res *res){	struct wpa_bss *bss;	bss = os_zalloc(sizeof(*bss) + res->ie_len + res->beacon_ie_len);	if (bss == NULL)		return;	bss->id = wpa_s->bss_next_id++;	bss->last_update_idx = wpa_s->bss_update_idx;	wpa_bss_copy_res(bss, res);	os_memcpy(bss->ssid, ssid, ssid_len);	bss->ssid_len = ssid_len;	bss->ie_len = res->ie_len;	bss->beacon_ie_len = res->beacon_ie_len;	os_memcpy(bss + 1, res + 1, res->ie_len + res->beacon_ie_len);	dl_list_add_tail(&wpa_s->bss, &bss->list);	dl_list_add_tail(&wpa_s->bss_id, &bss->list_id);	wpa_s->num_bss++;	wpa_printf(MSG_DEBUG, "BSS: Add new id %u BSSID " MACSTR " SSID '%s'",		   bss->id, MAC2STR(bss->bssid), wpa_ssid_txt(ssid, ssid_len));	wpas_notify_bss_added(wpa_s, bss->bssid, bss->id);	if (wpa_s->num_bss > wpa_s->conf->bss_max_count) {		/* Remove the oldest entry */		wpa_bss_remove(wpa_s, dl_list_first(&wpa_s->bss,						    struct wpa_bss, list));	}

void sme_associate(struct wpa_supplicant *wpa_s, enum wpas_mode mode,		   const u8 *bssid, u16 auth_type){	struct wpa_driver_associate_params params;	struct ieee802_11_elems elems;	os_memset(&params, 0, sizeof(params));	params.bssid = bssid;	params.ssid = wpa_s->sme.ssid;	params.ssid_len = wpa_s->sme.ssid_len;	params.freq = wpa_s->sme.freq;	params.wpa_ie = wpa_s->sme.assoc_req_ie_len ?		wpa_s->sme.assoc_req_ie : NULL;	params.wpa_ie_len = wpa_s->sme.assoc_req_ie_len;#ifdef CONFIG_IEEE80211R	if (auth_type == WLAN_AUTH_FT && wpa_s->sme.ft_ies) {		params.wpa_ie = wpa_s->sme.ft_ies;		params.wpa_ie_len = wpa_s->sme.ft_ies_len;	}#endif /* CONFIG_IEEE80211R */	params.mode = mode;	params.mgmt_frame_protection = wpa_s->sme.mfp;	if (wpa_s->sme.prev_bssid_set)		params.prev_bssid = wpa_s->sme.prev_bssid;	wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR		" (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),		params.ssid ? wpa_ssid_txt(params.ssid, params.ssid_len) : "",		params.freq);	wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);	if (params.wpa_ie == NULL ||	    ieee802_11_parse_elems(params.wpa_ie, params.wpa_ie_len, &elems, 0)	    < 0) {		wpa_printf(MSG_DEBUG, "SME: Could not parse own IEs?!");		os_memset(&elems, 0, sizeof(elems));	}	if (elems.rsn_ie)		wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.rsn_ie - 2,					elems.rsn_ie_len + 2);	else if (elems.wpa_ie)		wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.wpa_ie - 2,					elems.wpa_ie_len + 2);	else		wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);	if (wpa_drv_associate(wpa_s, &params) < 0) {		wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "			"failed");		//wpa_supplicant_req_scan(wpa_s, 5, 0);                ros_assoc_failed(wpa_s, bssid, "Driver request to associate failed");		return;	}	/* TODO: add timeout on association */}

static void wpa_bss_remove(struct wpa_supplicant *wpa_s, struct wpa_bss *bss){	dl_list_del(&bss->list);	dl_list_del(&bss->list_id);	wpa_s->num_bss--;	wpa_printf(MSG_DEBUG, "BSS: Remove id %u BSSID " MACSTR " SSID '%s'",		   bss->id, MAC2STR(bss->bssid),		   wpa_ssid_txt(bss->ssid, bss->ssid_len));	wpas_notify_bss_removed(wpa_s, bss->bssid, bss->id);	os_free(bss);}

//Start MANAstatic void log_ssid(const u8 *ssid, size_t ssid_len, const u8 *mac) {	//Quick hack to output observed MACs & SSIDs	//TODO: Fix this so it works in loud mode, right now will only log an SSID once	char *mana_outfile = getenv("MANAOUTFILE");	FILE *f = fopen(mana_outfile, "a");	if (f != NULL) {		int rand=0;		if (mac[0] & 2) //Check if locally administered aka random MAC			rand=1;			fprintf(f,MACSTR ", %s, %d/n", MAC2STR(mac), wpa_ssid_txt(ssid, ssid_len), rand);		fclose(f);	}}

static int wpa_supplicant_ctrl_iface_list_networks(	struct wpa_supplicant *wpa_s, char *buf, size_t buflen){	char *pos, *end;	struct wpa_ssid *ssid;	int ret;	pos = buf;	end = buf + buflen;	ret = os_snprintf(pos, end - pos,			  "network id / ssid / bssid / flags/n");	if (ret < 0 || ret >= end - pos)		return pos - buf;	pos += ret;	ssid = wpa_s->conf->ssid;	while (ssid) {		ret = os_snprintf(pos, end - pos, "%d/t%s",				  ssid->id,				  wpa_ssid_txt(ssid->ssid, ssid->ssid_len));		if (ret < 0 || ret >= end - pos)			return pos - buf;		pos += ret;		if (ssid->bssid_set) {			ret = os_snprintf(pos, end - pos, "/t" MACSTR,					  MAC2STR(ssid->bssid));		} else {			ret = os_snprintf(pos, end - pos, "/tany");		}		if (ret < 0 || ret >= end - pos)			return pos - buf;		pos += ret;		ret = os_snprintf(pos, end - pos, "/t%s%s",				  ssid == wpa_s->current_ssid ?				  "[CURRENT]" : "",				  ssid->disabled ? "[DISABLED]" : "");		if (ret < 0 || ret >= end - pos)			return pos - buf;		pos += ret;		ret = os_snprintf(pos, end - pos, "/n");		if (ret < 0 || ret >= end - pos)			return pos - buf;		pos += ret;		ssid = ssid->next;	}	return pos - buf;}

/** * wpa_config_debug_dump_networks - Debug dump of configured networks * @config: Configuration data from wpa_config_read() */void wpa_config_debug_dump_networks(struct wpa_config *config){	int prio;	struct wpa_ssid *ssid;	for (prio = 0; prio < config->num_prio; prio++) {		ssid = config->pssid[prio];		wpa_printf(MSG_DEBUG, "Priority group %d",			   ssid->priority);		while (ssid) {			wpa_printf(MSG_DEBUG, "   id=%d ssid='%s'",				   ssid->id,				   wpa_ssid_txt(ssid->ssid, ssid->ssid_len));			ssid = ssid->pnext;		}	}}

static int wpa_supplicant_ctrl_iface_status(struct wpa_supplicant *wpa_s,					    const char *params,					    char *buf, size_t buflen){	char *pos, *end;	int res, verbose;	verbose = strcmp(params, "-VERBOSE") == 0;	pos = buf;	end = buf + buflen;	pos += snprintf(pos, end - pos, "bssid=" MACSTR "/n",			MAC2STR(wpa_s->bssid));	if (wpa_s->current_ssid) {		pos += snprintf(pos, end - pos, "ssid=%s/n",				wpa_ssid_txt(wpa_s->current_ssid->ssid,					     wpa_s->current_ssid->ssid_len));	}	pos += snprintf(pos, end - pos,			"pairwise_cipher=%s/n"			"group_cipher=%s/n"			"key_mgmt=%s/n"			"wpa_state=%s/n",			wpa_cipher_txt(wpa_s->pairwise_cipher),			wpa_cipher_txt(wpa_s->group_cipher),			wpa_key_mgmt_txt(wpa_s->key_mgmt, wpa_s->proto),			wpa_state_txt(wpa_s->wpa_state));	res = eapol_sm_get_status(wpa_s->eapol, pos, end - pos, verbose);	if (res >= 0)		pos += res;	if (wpa_s->preauth_eapol) {		pos += snprintf(pos, end - pos, "Pre-authentication "				"EAPOL state machines:/n");		res = eapol_sm_get_status(wpa_s->preauth_eapol,					  pos, end - pos, verbose);		if (res >= 0)			pos += res;	}	return pos - buf;}

static void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,    dladm_wlan_ess_t *bss, struct wpa_ssid *ssid){	uint8_t wpa_ie[IEEE80211_MAX_OPT_IE];	int wpa_ie_len;	wpa_s->reassociate = 0;	wpa_printf(MSG_DEBUG, "Trying to associate with " MACSTR	    " (SSID='%s' freq=%d MHz)", MAC2STR(bss->we_bssid.wb_bytes),	    wpa_ssid_txt((char *)ssid->ssid, ssid->ssid_len), bss->we_freq);	wpa_supplicant_cancel_scan(wpa_s);	if (bss->we_wpa_ie_len &&	    (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK))) {		wpa_s->cur_pmksa = pmksa_cache_get(wpa_s,		    bss->we_bssid.wb_bytes, NULL);		if (wpa_s->cur_pmksa) {			wpa_hexdump(MSG_DEBUG, "RSN: PMKID",			    wpa_s->cur_pmksa->pmkid, PMKID_LEN);		}		if (wpa_supplicant_set_suites(wpa_s, bss, ssid,		    wpa_ie, &wpa_ie_len)) {			wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "			    "management and encryption suites");			return;		}	} else {		wpa_ie_len = 0;	}	wpa_clear_keys(wpa_s, bss->we_bssid.wb_bytes);	wpa_s->wpa_state = WPA_ASSOCIATING;	wpa_s->driver->associate(wpa_s->linkid,	    (const char *)bss->we_bssid.wb_bytes, wpa_ie, wpa_ie_len);	/* Timeout for IEEE 802.11 authentication and association */	wpa_supplicant_req_auth_timeout(wpa_s, 15, 0);}

static struct wpa_scan_res *wpa_supplicant_select_bss_wapi(struct wpa_supplicant *wpa_s,			      struct wpa_ssid *group,			      struct wpa_ssid **selected_ssid){	struct wpa_ssid *ssid;	struct wpa_scan_res *bss;	size_t i;	struct wpa_blacklist *e;	const u8 *ie;	wpa_printf(MSG_DEBUG, "Try to find WAPI-enabled AP");	for (i = 0; i < wpa_s->scan_res->num; i++) {		const u8 *ssid_;		u8 wapi_ie_len, ssid_len;		bss = wpa_s->scan_res->res[i];		ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);		ssid_ = ie ? ie + 2 : (u8 *) "";		ssid_len = ie ? ie[1] : 0;		//ie = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);		//wpa_ie_len = ie ? ie[1] : 0;		ie = wpa_scan_get_ie(bss, WAPI_INFO_ELEM);		wapi_ie_len = ie ? ie[1] : 0;		wpa_printf(MSG_DEBUG, "%d: " MACSTR " ssid='%s' "			   "wapi_ie_len=%u caps=0x%x",			   (int) i, MAC2STR(bss->bssid),			   wpa_ssid_txt(ssid_, ssid_len),			   wapi_ie_len, bss->caps);		e = wpa_blacklist_get(wpa_s, bss->bssid);		if (e && e->count > 1) {			wpa_printf(MSG_DEBUG, "   skip - blacklisted");			continue;		}		if (ssid_len == 0) {			wpa_printf(MSG_DEBUG, "   skip - SSID not known");			continue;		}		if (wapi_ie_len == 0) {			wpa_printf(MSG_DEBUG, "   skip - no WAPI IE");			continue;		}		for (ssid = group; ssid; ssid = ssid->pnext) {			int check_ssid = 1;			if (ssid->disabled) {				wpa_printf(MSG_DEBUG, "   skip - disabled");				continue;			}			if (check_ssid &&			    (ssid_len != ssid->ssid_len ||			     os_memcmp(ssid_, ssid->ssid, ssid_len) != 0)) {				wpa_printf(MSG_DEBUG, "   skip - "					   "SSID mismatch");				continue;			}			if (ssid->bssid_set &&			    os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0)			{				wpa_printf(MSG_DEBUG, "   skip - "					   "BSSID mismatch");				continue;			}			if (!wpa_supplicant_ssid_wapi_bss_match(wpa_s, ssid, bss))				continue;			{				/*					Record the WAPI AP's IE, will be reported to WAPI Module				*/				const u8* wapi_ie;				wapi_ie = wpa_scan_get_ie(bss, WAPI_INFO_ELEM);				wpa_s->bss_wapi_ie_len = 2 + wapi_ie[1];				os_memcpy(wpa_s->bss_wapi_ie, wapi_ie, wpa_s->bss_wapi_ie_len);				wpa_printf(MSG_DEBUG, "[WAPI-Debug ^_^]  selected WAPI AP !!!!!!! Ready to connect +_+");			}			wpa_printf(MSG_DEBUG, "   selected WAPI AP "				   MACSTR " ssid='%s'",				   MAC2STR(bss->bssid),				   wpa_ssid_txt(ssid_, ssid_len));			*selected_ssid = ssid;			return bss;		}	}	return NULL;}

//.........这里部分代码省略.........		pos = wpa_s->sme.assoc_req_ie + wpa_s->sme.assoc_req_ie_len;		len = sizeof(wpa_s->sme.assoc_req_ie) -			wpa_s->sme.assoc_req_ie_len;		res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,					    ssid->p2p_group);		if (res >= 0)			wpa_s->sme.assoc_req_ie_len += res;	}#endif /* CONFIG_P2P */#ifdef CONFIG_HS20	if (wpa_s->conf->hs20) {		struct wpabuf *hs20;		hs20 = wpabuf_alloc(20);		if (hs20) {			wpas_hs20_add_indication(hs20);			os_memcpy(wpa_s->sme.assoc_req_ie +				  wpa_s->sme.assoc_req_ie_len,				  wpabuf_head(hs20), wpabuf_len(hs20));			wpa_s->sme.assoc_req_ie_len += wpabuf_len(hs20);			wpabuf_free(hs20);		}	}#endif /* CONFIG_HS20 */#ifdef CONFIG_INTERWORKING	if (wpa_s->conf->interworking) {		u8 *pos = wpa_s->sme.assoc_req_ie;		if (wpa_s->sme.assoc_req_ie_len > 0 && pos[0] == WLAN_EID_RSN)			pos += 2 + pos[1];		os_memmove(pos + 6, pos,			   wpa_s->sme.assoc_req_ie_len -			   (pos - wpa_s->sme.assoc_req_ie));		wpa_s->sme.assoc_req_ie_len += 6;		*pos++ = WLAN_EID_EXT_CAPAB;		*pos++ = 4;		*pos++ = 0x00;		*pos++ = 0x00;		*pos++ = 0x00;		*pos++ = 0x80; /* Bit 31 - Interworking */	}#endif /* CONFIG_INTERWORKING */	wpa_supplicant_cancel_sched_scan(wpa_s);	wpa_supplicant_cancel_scan(wpa_s);	wpa_msg(wpa_s, MSG_INFO, "SME: Trying to authenticate with " MACSTR		" (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),		wpa_ssid_txt(params.ssid, params.ssid_len), params.freq);	wpa_clear_keys(wpa_s, bss->bssid);	wpa_supplicant_set_state(wpa_s, WPA_AUTHENTICATING);	old_ssid = wpa_s->current_ssid;	wpa_s->current_ssid = ssid;	wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);	wpa_supplicant_initiate_eapol(wpa_s);	if (old_ssid != wpa_s->current_ssid)		wpas_notify_network_changed(wpa_s);	wpa_s->sme.auth_alg = params.auth_alg;#if defined(ANDROID_P2P) && defined(WIFI_EAGLE)	/* If multichannel concurrency is not supported, check for any frequency	 * conflict and take appropriate action.	 */	wpa_printf(MSG_DEBUG, "%s EAGLE: Priority choose", __func__);	if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MULTI_CHANNEL_CONCURRENT) &&		((freq = wpa_drv_shared_freq(wpa_s)) > 0) && (freq != params.freq)) {		wpa_printf(MSG_DEBUG, "Shared interface with conflicting frequency found (%d != %d)"				, freq, params.freq);		if (wpas_p2p_handle_frequency_conflicts(wpa_s, params.freq) < 0) {			/* Handling conflicts failed. Disable the current connect req and			 * notify the userspace to take appropriate action */			wpa_printf(MSG_DEBUG, "proiritize is not set. Notifying user space to handle the case");			wpa_supplicant_disable_network(wpa_s, ssid);			wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_FREQ_CONFLICT				" id=%d", ssid->id);			os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);			return;		}	}#endif /* ANDROID_P2P && WIFI_EAGLE */	if (wpa_drv_authenticate(wpa_s, &params) < 0) {		wpa_msg(wpa_s, MSG_INFO, "SME: Authentication request to the "			"driver failed");		wpas_connection_failed(wpa_s, bss->bssid);		wpa_supplicant_mark_disassoc(wpa_s);		return;	}	eloop_register_timeout(SME_AUTH_TIMEOUT, 0, sme_auth_timer, wpa_s,			       NULL);	/*	 * Association will be started based on the authentication event from	 * the driver.	 */}

static struct wpa_scan_res *wpa_supplicant_select_bss_non_wpa(struct wpa_supplicant *wpa_s,				  struct wpa_ssid *group,				  struct wpa_ssid **selected_ssid){	struct wpa_ssid *ssid;	struct wpa_scan_res *bss;	size_t i;	struct wpa_blacklist *e;	const u8 *ie;	wpa_printf(MSG_DEBUG, "Try to find non-WPA AP");	for (i = 0; i < wpa_s->scan_res->num; i++) {		const u8 *ssid_;		u8 wpa_ie_len, rsn_ie_len, ssid_len;		bss = wpa_s->scan_res->res[i];		ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);		ssid_ = ie ? ie + 2 : (u8 *) "";		ssid_len = ie ? ie[1] : 0;		ie = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);		wpa_ie_len = ie ? ie[1] : 0;		ie = wpa_scan_get_ie(bss, WLAN_EID_RSN);		rsn_ie_len = ie ? ie[1] : 0;		wpa_printf(MSG_DEBUG, "%d: " MACSTR " ssid='%s' "			   "wpa_ie_len=%u rsn_ie_len=%u caps=0x%x",			   (int) i, MAC2STR(bss->bssid),			   wpa_ssid_txt(ssid_, ssid_len),			   wpa_ie_len, rsn_ie_len, bss->caps);		e = wpa_blacklist_get(wpa_s, bss->bssid);		if (e && e->count > 1) {			wpa_printf(MSG_DEBUG, "   skip - blacklisted");			continue;		}		if (ssid_len == 0) {			wpa_printf(MSG_DEBUG, "   skip - SSID not known");			continue;		}		for (ssid = group; ssid; ssid = ssid->pnext) {			int check_ssid = ssid->ssid_len != 0;			if (ssid->disabled) {				wpa_printf(MSG_DEBUG, "   skip - disabled");				continue;			}#ifdef CONFIG_WPS			if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {				/* Only allow wildcard SSID match if an AP				 * advertises active WPS operation that matches				 * with our mode. */				check_ssid = 1;				if (ssid->ssid_len == 0 &&				    wpas_wps_ssid_wildcard_ok(wpa_s, ssid,							      bss))					check_ssid = 0;			}#endif /* CONFIG_WPS */			if (check_ssid &&			    (ssid_len != ssid->ssid_len ||			     os_memcmp(ssid_, ssid->ssid, ssid_len) != 0)) {				wpa_printf(MSG_DEBUG, "   skip - "					   "SSID mismatch");				continue;			}			if (ssid->bssid_set &&			    os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0)			{				wpa_printf(MSG_DEBUG, "   skip - "					   "BSSID mismatch");				continue;			}			if (!(ssid->key_mgmt & WPA_KEY_MGMT_NONE) &&			    !(ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&			    !(ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA))			{				wpa_printf(MSG_DEBUG, "   skip - "					   "non-WPA network not allowed");				continue;			}			if ((ssid->key_mgmt &			     (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |			      WPA_KEY_MGMT_FT_IEEE8021X | WPA_KEY_MGMT_FT_PSK |			      WPA_KEY_MGMT_IEEE8021X_SHA256 |			      WPA_KEY_MGMT_PSK_SHA256)) &&			    (wpa_ie_len != 0 || rsn_ie_len != 0)) {				wpa_printf(MSG_DEBUG, "   skip - "					   "WPA network");				continue;			}//.........这里部分代码省略.........

//.........这里部分代码省略.........	sme_auth_handle_rrm(wpa_s, bss);#ifdef CONFIG_SAE	if (!skip_auth && params.auth_alg == WPA_AUTH_ALG_SAE &&	    pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid, ssid, 0) == 0)	{		wpa_dbg(wpa_s, MSG_DEBUG,			"PMKSA cache entry found - try to use PMKSA caching instead of new SAE authentication");		params.auth_alg = WPA_AUTH_ALG_OPEN;		wpa_s->sme.sae_pmksa_caching = 1;	}	if (!skip_auth && params.auth_alg == WPA_AUTH_ALG_SAE) {		if (start)			resp = sme_auth_build_sae_commit(wpa_s, ssid,							 bss->bssid);		else			resp = sme_auth_build_sae_confirm(wpa_s);		if (resp == NULL) {			wpas_connection_failed(wpa_s, bss->bssid, 1);			return;		}		params.sae_data = wpabuf_head(resp);		params.sae_data_len = wpabuf_len(resp);		wpa_s->sme.sae.state = start ? SAE_COMMITTED : SAE_CONFIRMED;	}#endif /* CONFIG_SAE */	wpa_supplicant_cancel_sched_scan(wpa_s);	wpa_supplicant_cancel_scan(wpa_s);	wpa_msg(wpa_s, MSG_INFO, "SME: Trying to authenticate with " MACSTR		" (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),		wpa_ssid_txt(params.ssid, params.ssid_len), params.freq);	wpa_clear_keys(wpa_s, bss->bssid);	wpa_supplicant_set_state(wpa_s, WPA_AUTHENTICATING);	old_ssid = wpa_s->current_ssid;	wpa_s->current_ssid = ssid;	wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);	wpa_supplicant_initiate_eapol(wpa_s);	if (old_ssid != wpa_s->current_ssid)		wpas_notify_network_changed(wpa_s);#ifdef CONFIG_P2P	/*	 * If multi-channel concurrency is not supported, check for any	 * frequency conflict. In case of any frequency conflict, remove the	 * least prioritized connection.	 */	if (wpa_s->num_multichan_concurrent < 2) {		int freq, num;		num = get_shared_radio_freqs(wpa_s, &freq, 1);		if (num > 0 && freq > 0 && freq != params.freq) {			wpa_printf(MSG_DEBUG,				   "Conflicting frequency found (%d != %d)",				   freq, params.freq);			if (wpas_p2p_handle_frequency_conflicts(wpa_s,								params.freq,								ssid) < 0) {				wpas_connection_failed(wpa_s, bss->bssid, 0);				wpa_supplicant_mark_disassoc(wpa_s);				wpabuf_free(resp);				wpas_connect_work_done(wpa_s);				return;			}

int wpa_supplicant_create_ap(struct wpa_supplicant *wpa_s,			     struct wpa_ssid *ssid){	struct wpa_driver_associate_params params;	struct hostapd_iface *hapd_iface;	struct hostapd_config *conf;	struct hostapd_data *hapd;	size_t i;	if (ssid->ssid == NULL || ssid->ssid_len == 0) {		wpa_printf(MSG_ERROR, "No SSID configured for AP mode");		return -1;	}	wpa_supplicant_ap_deinit(wpa_s);	wpa_printf(MSG_DEBUG, "Setting up AP (SSID='%s')",		   wpa_ssid_txt(ssid->ssid, ssid->ssid_len));	os_memset(&params, 0, sizeof(params));	params.ssid = ssid->ssid;	params.ssid_len = ssid->ssid_len;	switch (ssid->mode) {	case WPAS_MODE_INFRA:		params.mode = IEEE80211_MODE_INFRA;		break;	case WPAS_MODE_IBSS:		params.mode = IEEE80211_MODE_IBSS;		break;	case WPAS_MODE_AP:	case WPAS_MODE_P2P_GO:	case WPAS_MODE_P2P_GROUP_FORMATION:		params.mode = IEEE80211_MODE_AP;		break;	}	params.freq = ssid->frequency;	if (ssid->key_mgmt & WPA_KEY_MGMT_PSK)		wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;	else		wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;	params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);	if (ssid->pairwise_cipher & WPA_CIPHER_CCMP)		wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;	else if (ssid->pairwise_cipher & WPA_CIPHER_TKIP)		wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;	else if (ssid->pairwise_cipher & WPA_CIPHER_NONE)		wpa_s->pairwise_cipher = WPA_CIPHER_NONE;	else {		wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "			   "cipher.");		return -1;	}	params.pairwise_suite = cipher_suite2driver(wpa_s->pairwise_cipher);	params.group_suite = params.pairwise_suite;#ifdef CONFIG_P2P	if (ssid->mode == WPAS_MODE_P2P_GO ||	    ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)		params.p2p = 1;	wpa_drv_set_intra_bss(wpa_s, wpa_s->conf->p2p_intra_bss);#endif /* CONFIG_P2P */	if (wpa_s->parent->set_ap_uapsd)		params.uapsd = wpa_s->parent->ap_uapsd;	else		params.uapsd = -1;	if (wpa_drv_associate(wpa_s, &params) < 0) {		wpa_msg(wpa_s, MSG_INFO, "Failed to start AP functionality");		return -1;	}	wpa_s->ap_iface = hapd_iface = os_zalloc(sizeof(*wpa_s->ap_iface));	if (hapd_iface == NULL)		return -1;	hapd_iface->owner = wpa_s;	wpa_s->ap_iface->conf = conf = hostapd_config_defaults();	if (conf == NULL) {		wpa_supplicant_ap_deinit(wpa_s);		return -1;	}	if (wpa_supplicant_conf_ap(wpa_s, ssid, conf)) {		wpa_printf(MSG_ERROR, "Failed to create AP configuration");		wpa_supplicant_ap_deinit(wpa_s);		return -1;	}#ifdef CONFIG_P2P	if (ssid->mode == WPAS_MODE_P2P_GO)		conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER;	else if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)		conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER |			P2P_GROUP_FORMATION;#endif /* CONFIG_P2P */	hapd_iface->num_bss = conf->num_bss;//.........这里部分代码省略.........

static struct wpa_scan_res *wpa_supplicant_select_bss_wpa(struct wpa_supplicant *wpa_s,			      struct wpa_ssid *group,			      struct wpa_ssid **selected_ssid){	struct wpa_ssid *ssid;	struct wpa_scan_res *bss;	size_t i;	struct wpa_blacklist *e;	const u8 *ie;	wpa_printf(MSG_DEBUG, "Try to find WPA-enabled AP");	for (i = 0; i < wpa_s->scan_res->num; i++) {		const u8 *ssid_;		u8 wpa_ie_len, rsn_ie_len, ssid_len;		bss = wpa_s->scan_res->res[i];		ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);		ssid_ = ie ? ie + 2 : (u8 *) "";		ssid_len = ie ? ie[1] : 0;		ie = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);		wpa_ie_len = ie ? ie[1] : 0;		ie = wpa_scan_get_ie(bss, WLAN_EID_RSN);		rsn_ie_len = ie ? ie[1] : 0;		wpa_printf(MSG_DEBUG, "%d: " MACSTR " ssid='%s' "			   "wpa_ie_len=%u rsn_ie_len=%u caps=0x%x",			   (int) i, MAC2STR(bss->bssid),			   wpa_ssid_txt(ssid_, ssid_len),			   wpa_ie_len, rsn_ie_len, bss->caps);		e = wpa_blacklist_get(wpa_s, bss->bssid);		if (e && e->count > 1) {			wpa_printf(MSG_DEBUG, "   skip - blacklisted");			continue;		}		if (ssid_len == 0) {			wpa_printf(MSG_DEBUG, "   skip - SSID not known");			continue;		}		if (wpa_ie_len == 0 && rsn_ie_len == 0) {			wpa_printf(MSG_DEBUG, "   skip - no WPA/RSN IE");			continue;		}		for (ssid = group; ssid; ssid = ssid->pnext) {			int check_ssid = 1;			if (ssid->disabled) {				wpa_printf(MSG_DEBUG, "   skip - disabled");				continue;			}#ifdef CONFIG_WPS			if (ssid->ssid_len == 0 &&			    wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss))				check_ssid = 0;#endif /* CONFIG_WPS */			if (check_ssid &&			    (ssid_len != ssid->ssid_len ||			     os_memcmp(ssid_, ssid->ssid, ssid_len) != 0)) {				wpa_printf(MSG_DEBUG, "   skip - "					   "SSID mismatch");				continue;			}			if (ssid->bssid_set &&			    os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0)			{				wpa_printf(MSG_DEBUG, "   skip - "					   "BSSID mismatch");				continue;			}			if (!wpa_supplicant_ssid_bss_match(wpa_s, ssid, bss))				continue;			wpa_printf(MSG_DEBUG, "   selected WPA AP "				   MACSTR " ssid='%s'",				   MAC2STR(bss->bssid),				   wpa_ssid_txt(ssid_, ssid_len));			*selected_ssid = ssid;			return bss;		}	}	return NULL;}

//.........这里部分代码省略.........		for (tssid = wpa_s->conf->ssid; tssid; tssid = tssid->next) {			if (wpas_network_disabled(wpa_s, tssid))				continue;			if ((params.freqs || !freqs_set) && tssid->scan_freq) {				int_array_concat(&params.freqs,						 tssid->scan_freq);			} else {				os_free(params.freqs);				params.freqs = NULL;			}			freqs_set = 1;		}		int_array_sort_unique(params.freqs);	}	if (ssid && max_ssids == 1) {		/*		 * If the driver is limited to 1 SSID at a time interleave		 * wildcard SSID scans with specific SSID scans to avoid		 * waiting a long time for a wildcard scan.		 */		if (!wpa_s->prev_scan_wildcard) {			params.ssids[0].ssid = NULL;			params.ssids[0].ssid_len = 0;			wpa_s->prev_scan_wildcard = 1;			wpa_dbg(wpa_s, MSG_DEBUG, "Starting AP scan for "				"wildcard SSID (Interleave with specific)");		} else {			wpa_s->prev_scan_ssid = ssid;			wpa_s->prev_scan_wildcard = 0;			wpa_dbg(wpa_s, MSG_DEBUG,				"Starting AP scan for specific SSID: %s",				wpa_ssid_txt(ssid->ssid, ssid->ssid_len));		}	} else if (ssid) {		/* max_ssids > 1 */		wpa_s->prev_scan_ssid = ssid;		wpa_dbg(wpa_s, MSG_DEBUG, "Include wildcard SSID in "			"the scan request");		params.num_ssids++;	} else {		wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;		params.num_ssids++;		wpa_dbg(wpa_s, MSG_DEBUG, "Starting AP scan for wildcard "			"SSID");	}#ifdef CONFIG_P2Pssid_list_set:#endif /* CONFIG_P2P */	wpa_supplicant_optimize_freqs(wpa_s, &params);	extra_ie = wpa_supplicant_extra_ies(wpa_s);	if (params.freqs == NULL && wpa_s->next_scan_freqs) {		wpa_dbg(wpa_s, MSG_DEBUG, "Optimize scan based on previously "			"generated frequency list");		params.freqs = wpa_s->next_scan_freqs;	} else		os_free(wpa_s->next_scan_freqs);	wpa_s->next_scan_freqs = NULL;	wpa_setband_scan_freqs(wpa_s, &params);	/* See if user specified frequencies. If so, scan only those. */	if (wpa_s->conf->freq_list && !params.freqs) {

void sme_associate(struct wpa_supplicant *wpa_s, enum wpas_mode mode,		   const u8 *bssid, u16 auth_type){	struct wpa_driver_associate_params params;	struct ieee802_11_elems elems;#ifdef CONFIG_HT_OVERRIDES	struct ieee80211_ht_capabilities htcaps;	struct ieee80211_ht_capabilities htcaps_mask;#endif /* CONFIG_HT_OVERRIDES */	os_memset(&params, 0, sizeof(params));	params.bssid = bssid;	params.ssid = wpa_s->sme.ssid;	params.ssid_len = wpa_s->sme.ssid_len;	params.freq = wpa_s->sme.freq;	params.bg_scan_period = wpa_s->current_ssid ?		wpa_s->current_ssid->bg_scan_period : -1;	params.wpa_ie = wpa_s->sme.assoc_req_ie_len ?		wpa_s->sme.assoc_req_ie : NULL;	params.wpa_ie_len = wpa_s->sme.assoc_req_ie_len;	params.pairwise_suite = cipher_suite2driver(wpa_s->pairwise_cipher);	params.group_suite = cipher_suite2driver(wpa_s->group_cipher);#ifdef CONFIG_HT_OVERRIDES	os_memset(&htcaps, 0, sizeof(htcaps));	os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));	params.htcaps = (u8 *) &htcaps;	params.htcaps_mask = (u8 *) &htcaps_mask;	wpa_supplicant_apply_ht_overrides(wpa_s, wpa_s->current_ssid, &params);#endif /* CONFIG_HT_OVERRIDES */#ifdef CONFIG_IEEE80211R	if (auth_type == WLAN_AUTH_FT && wpa_s->sme.ft_ies) {		params.wpa_ie = wpa_s->sme.ft_ies;		params.wpa_ie_len = wpa_s->sme.ft_ies_len;	}#endif /* CONFIG_IEEE80211R */	params.mode = mode;	params.mgmt_frame_protection = wpa_s->sme.mfp;	if (wpa_s->sme.prev_bssid_set)		params.prev_bssid = wpa_s->sme.prev_bssid;	wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR		" (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),		params.ssid ? wpa_ssid_txt(params.ssid, params.ssid_len) : "",		params.freq);	wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);	if (params.wpa_ie == NULL ||	    ieee802_11_parse_elems(params.wpa_ie, params.wpa_ie_len, &elems, 0)	    < 0) {		wpa_dbg(wpa_s, MSG_DEBUG, "SME: Could not parse own IEs?!");		os_memset(&elems, 0, sizeof(elems));	}	if (elems.rsn_ie) {		params.wpa_proto = WPA_PROTO_RSN;		wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.rsn_ie - 2,					elems.rsn_ie_len + 2);	} else if (elems.wpa_ie) {		params.wpa_proto = WPA_PROTO_WPA;		wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.wpa_ie - 2,					elems.wpa_ie_len + 2);	} else		wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);	if (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group)		params.p2p = 1;	if (wpa_s->parent->set_sta_uapsd)		params.uapsd = wpa_s->parent->sta_uapsd;	else		params.uapsd = -1;	if (wpa_drv_associate(wpa_s, &params) < 0) {		wpa_msg(wpa_s, MSG_INFO, "SME: Association request to the "			"driver failed");		wpas_connection_failed(wpa_s, wpa_s->pending_bssid);		wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);		os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);		return;	}	eloop_register_timeout(SME_ASSOC_TIMEOUT, 0, sme_assoc_timer, wpa_s,			       NULL);}

static int wpa_supplicant_ctrl_iface_status(struct wpa_supplicant *wpa_s,					    const char *params,					    char *buf, size_t buflen){	char *pos, *end, tmp[30];	int res, verbose, ret;	verbose = os_strcmp(params, "-VERBOSE") == 0;	pos = buf;	end = buf + buflen;	if (wpa_s->wpa_state >= WPA_ASSOCIATED) {		struct wpa_ssid *ssid = wpa_s->current_ssid;		ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "/n",				  MAC2STR(wpa_s->bssid));		if (ret < 0 || ret >= end - pos)			return pos - buf;		pos += ret;		if (ssid) {			u8 *_ssid = ssid->ssid;			size_t ssid_len = ssid->ssid_len;			u8 ssid_buf[MAX_SSID_LEN];			if (ssid_len == 0) {				int _res = wpa_drv_get_ssid(wpa_s, ssid_buf);				if (_res < 0)					ssid_len = 0;				else					ssid_len = _res;				_ssid = ssid_buf;			}			ret = os_snprintf(pos, end - pos, "ssid=%s/nid=%d/n",					  wpa_ssid_txt(_ssid, ssid_len),					  ssid->id);			if (ret < 0 || ret >= end - pos)				return pos - buf;			pos += ret;			if (ssid->id_str) {				ret = os_snprintf(pos, end - pos,						  "id_str=%s/n",						  ssid->id_str);				if (ret < 0 || ret >= end - pos)					return pos - buf;				pos += ret;			}		}		pos += wpa_sm_get_status(wpa_s->wpa, pos, end - pos, verbose);	}	ret = os_snprintf(pos, end - pos, "wpa_state=%s/n",			  wpa_supplicant_state_txt(wpa_s->wpa_state));	if (ret < 0 || ret >= end - pos)		return pos - buf;	pos += ret;	if (wpa_s->l2 &&	    l2_packet_get_ip_addr(wpa_s->l2, tmp, sizeof(tmp)) >= 0) {		ret = os_snprintf(pos, end - pos, "ip_address=%s/n", tmp);		if (ret < 0 || ret >= end - pos)			return pos - buf;		pos += ret;	}	if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||	    wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {		res = eapol_sm_get_status(wpa_s->eapol, pos, end - pos,					  verbose);		if (res >= 0)			pos += res;	}	res = rsn_preauth_get_status(wpa_s->wpa, pos, end - pos, verbose);	if (res >= 0)		pos += res;	return pos - buf;}

static int wpa_supplicant_ctrl_iface_scan_results(	struct wpa_supplicant *wpa_s, char *buf, size_t buflen){	char *pos, *end, *retpos;	struct wpa_scan_result *res;	int i, ret;	if (wpa_s->scan_results == NULL &&	    wpa_supplicant_get_scan_results(wpa_s) < 0)		return 0;	if (wpa_s->scan_results == NULL)		return 0;	pos = buf;	end = buf + buflen;	ret = os_snprintf(pos, end - pos, "bssid / frequency / signal level / "			  "flags / ssid/n");	if (ret < 0 || ret >= end - pos)		return pos - buf;	pos += ret;	for (i = 0; i < wpa_s->num_scan_results; i++) {		retpos = pos;		res = &wpa_s->scan_results[i];		ret = os_snprintf(pos, end - pos, MACSTR "/t%d/t%d/t",				  MAC2STR(res->bssid), res->freq, res->level);		if (ret < 0 || ret >= end - pos)			return retpos - buf;		pos += ret;		if (res->wpa_ie_len) {			pos = wpa_supplicant_ie_txt(pos, end, "WPA",						    res->wpa_ie,						    res->wpa_ie_len);		}		if (res->rsn_ie_len) {			pos = wpa_supplicant_ie_txt(pos, end, "WPA2",						    res->rsn_ie,						    res->rsn_ie_len);		}		if (!res->wpa_ie_len && !res->rsn_ie_len &&		    res->caps & IEEE80211_CAP_PRIVACY) {			ret = os_snprintf(pos, end - pos, "[WEP]");			if (ret < 0 || ret >= end - pos)				return retpos - buf;			pos += ret;		}		if (res->caps & IEEE80211_CAP_IBSS) {			ret = os_snprintf(pos, end - pos, "[IBSS]");			if (ret < 0 || ret >= end - pos)				return retpos - buf;			pos += ret;		}		if (!res->wpa_ie_len && !res->rsn_ie_len) {			ret = os_snprintf(pos, end - pos, "/t");			if (ret < 0 || ret >= end - pos)				return retpos - buf;			pos += ret;		}		ret = os_snprintf(pos, end - pos, "/t%s",				  wpa_ssid_txt(res->ssid, res->ssid_len));		if (ret < 0 || ret >= end - pos)			return retpos - buf;		pos += ret;		ret = os_snprintf(pos, end - pos, "/n");		if (ret < 0 || ret >= end - pos)			return retpos - buf;		pos += ret;	}	return pos - buf;}

static struct wpa_ssid * wpa_scan_res_match(struct wpa_supplicant *wpa_s,					    int i, struct wpa_scan_res *bss,					    struct wpa_ssid *group){	const u8 *ssid_;	u8 wpa_ie_len, rsn_ie_len, ssid_len;	int wpa;	struct wpa_blacklist *e;	const u8 *ie;	struct wpa_ssid *ssid;	ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);	ssid_ = ie ? ie + 2 : (u8 *) "";	ssid_len = ie ? ie[1] : 0;	ie = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);	wpa_ie_len = ie ? ie[1] : 0;	ie = wpa_scan_get_ie(bss, WLAN_EID_RSN);	rsn_ie_len = ie ? ie[1] : 0;	wpa_printf(MSG_DEBUG, "%d: " MACSTR " ssid='%s' "		   "wpa_ie_len=%u rsn_ie_len=%u caps=0x%x level=%d%s",		   i, MAC2STR(bss->bssid), wpa_ssid_txt(ssid_, ssid_len),		   wpa_ie_len, rsn_ie_len, bss->caps, bss->level,		   wpa_scan_get_vendor_ie(bss, WPS_IE_VENDOR_TYPE) ?		   " wps" : "");	e = wpa_blacklist_get(wpa_s, bss->bssid);	if (e && e->count > 1) {		wpa_printf(MSG_DEBUG, "   skip - blacklisted");		return 0;	}	if (ssid_len == 0) {		wpa_printf(MSG_DEBUG, "   skip - SSID not known");		return 0;	}	wpa = wpa_ie_len > 0 || rsn_ie_len > 0;	for (ssid = group; ssid; ssid = ssid->pnext) {		int check_ssid = wpa ? 1 : (ssid->ssid_len != 0);		if (ssid->disabled) {			wpa_printf(MSG_DEBUG, "   skip - disabled");			continue;		}#ifdef CONFIG_WPS		if ((ssid->key_mgmt & WPA_KEY_MGMT_WPS) && e && e->count > 0) {			wpa_printf(MSG_DEBUG, "   skip - blacklisted (WPS)");			continue;		}		if (wpa && ssid->ssid_len == 0 &&		    wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss))			check_ssid = 0;		if (!wpa && (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {			/* Only allow wildcard SSID match if an AP			 * advertises active WPS operation that matches			 * with our mode. */			check_ssid = 1;			if (ssid->ssid_len == 0 &&			    wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss))				check_ssid = 0;		}#endif /* CONFIG_WPS */		if (check_ssid &&		    (ssid_len != ssid->ssid_len ||		     os_memcmp(ssid_, ssid->ssid, ssid_len) != 0)) {			wpa_printf(MSG_DEBUG, "   skip - SSID mismatch");			continue;		}		if (ssid->bssid_set &&		    os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0) {			wpa_printf(MSG_DEBUG, "   skip - BSSID mismatch");			continue;		}		if (wpa && !wpa_supplicant_ssid_bss_match(wpa_s, ssid, bss))			continue;		if (!wpa &&		    !(ssid->key_mgmt & WPA_KEY_MGMT_NONE) &&		    !(ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&		    !(ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)) {			wpa_printf(MSG_DEBUG, "   skip - non-WPA network not "				   "allowed");			continue;		}		if (!wpa && !wpa_supplicant_match_privacy(bss, ssid)) {			wpa_printf(MSG_DEBUG, "   skip - privacy mismatch");			continue;		}//.........这里部分代码省略.........