android WiFi ASSOC_REJECT 流程跟踪

Android设备在于AP关联时，如果AP返回关联拒绝帧，Android设别会把AP加入黑名单中。
黑名单中的设备将会在扫描时，延时一段时间放在后面处理。
代码以及log基于SDM450, Android O
10-26 22:49:44.937  2215  2215 D wpa_supplicant: nl80211: Drv Event 46 (NL80211_CMD_CONNECT) received for wlan0
10-26 22:49:44.937  2215  2215 D wpa_supplicant: nl80211: Connect event (status=1 ignore_next_local_disconnect=0)
10-26 22:49:44.937  2215  2215 D wpa_supplicant: wlan0: Event ASSOC_REJECT (13) received
10-26 22:49:44.937  2215  2215 I wpa_supplicant: wlan0: CTRL-EVENT-ASSOC-REJECT bssid=ac:a3:1e:90:a7:00 status_code=1
10-26 22:49:44.937  2215  2215 D wpa_supplicant: CTRL-DEBUG: ctrl_sock-sendmsg: sock=8 sndbuf=163840 outq=0 send_len=61
10-26 22:49:44.937  2215  2215 D wpa_supplicant: CTRL_IFACE monitor sent successfully to /data/misc/wifi/sockets/wpa_ctrl_1749-3\x00
10-26 22:49:44.937  2215  2215 D wpa_supplicant: wlan0: Radio work 'connect'@0xab316240 done in 1.284062 seconds
10-26 22:49:44.937  2215  2215 D wpa_supplicant: wlan0: radio_work_free('connect'@0xab316240: num_active_works --> 0
10-26 22:49:44.937  1749  2340 D WifiMonitor: Event [IFNAME=wlan0 CTRL-EVENT-ASSOC-REJECT bssid=ac:a3:1e:90:a7:00 status_code=1]
10-26 22:49:44.937  2215  2215 D wpa_supplicant: Added BSSID ac:a3:1e:90:a7:00 into blacklist
10-26 22:49:44.938  2215  2215 D wpa_supplicant: wlan0: Another BSS in this ESS has been seen; try it next		// ESS中还有其他的BSS
10-26 22:49:44.938  2215  2215 D wpa_supplicant: BSSID ac:a3:1e:90:a7:00 blacklist count incremented to 2
10-26 22:49:44.938  2215  2215 D wpa_supplicant: wlan0: Blacklist count 3 --> request scan in 1000 ms
10-26 22:49:44.938  2215  2215 D wpa_supplicant: wlan0: Setting scan request: 1.000000 sec
10-26 22:49:44.938  2215  2215 D wpa_supplicant: wlan0: State: ASSOCIATING -> DISCONNECTED

10-26 22:49:43.094  1749  2340 D WifiMonitor: Event [IFNAME=wlan0 CTRL-EVENT-ASSOC-REJECT bssid=ac:a3:1e:90:a7:00 status_code=1]
10-26 22:49:43.094  1749  2340 D WifiMonitor: wlan0 cnt=5727 dispatchEvent: CTRL-EVENT-ASSOC-REJECT bssid=ac:a3:1e:90:a7:00 status_code=1
10-26 22:49:43.095  1749  2340 D WifiMonitor: Event [IFNAME=wlan0 CTRL-EVENT-STATE-CHANGE id=0 state=0 BSSID=00:00:00:00:00:00 SSID=coupang]
10-26 22:49:43.095  1749  2340 D WifiMonitor: wlan0 cnt=5728 dispatchEvent: CTRL-EVENT-STATE-CHANGE id=0 state=0 BSSID=00:00:00:00:00:00 SSID=coupang
10-26 22:49:43.095  1749  2081 D WifiStateMachine:  DisconnectedState ASSOCIATION_REJECTION_EVENT  rt=13253916/14362444 5727 1 ac:a3:1e:90:a7:00 blacklist=false
10-26 22:49:43.095  1749  2081 D WifiStateMachine:  ConnectModeState ASSOCIATION_REJECTION_EVENT  rt=13253916/14362445 5727 1 ac:a3:1e:90:a7:00 blacklist=false

external\wpa_supplicant_8\wpa_supplicant\events.c
void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
			  union wpa_event_data *data)
{

	struct wpa_supplicant *wpa_s = ctx;
	int resched;

	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED &&
	    event != EVENT_INTERFACE_ENABLED &&
	    event != EVENT_INTERFACE_STATUS &&
	    event != EVENT_SCAN_RESULTS &&
	    event != EVENT_SCHED_SCAN_STOPPED) {
		wpa_dbg(wpa_s, MSG_DEBUG,
			"Ignore event %s (%d) while interface is disabled",
			event_to_string(event), event);
		return;
	}

#ifndef CONFIG_NO_STDOUT_DEBUG
{
	int level = MSG_DEBUG;

	if (event == EVENT_RX_MGMT && data->rx_mgmt.frame_len >= 24) {
		const struct ieee80211_hdr *hdr;
		u16 fc;
		hdr = (const struct ieee80211_hdr *) data->rx_mgmt.frame;
		fc = le_to_host16(hdr->frame_control);
		if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
		    WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON)
			level = MSG_EXCESSIVE;
	}
	//打印			Event ASSOC_REJECT (13) received
	wpa_dbg(wpa_s, level, "Event %s (%d) received",
		event_to_string(event), event);
}

	case EVENT_ASSOC_REJECT:                // 处理关联拒绝事件
		if (data->assoc_reject.bssid)
		//打印结果：wlan0: CTRL-EVENT-ASSOC-REJECT bssid=ac:a3:1e:90:a7:00 status_code=1
			wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
				"bssid=" MACSTR	" status_code=%u%s%s%s",
				MAC2STR(data->assoc_reject.bssid),
				data->assoc_reject.status_code,
				data->assoc_reject.timed_out ? " timeout" : "",
				data->assoc_reject.timeout_reason ? "=" : "",
				data->assoc_reject.timeout_reason ?
				data->assoc_reject.timeout_reason : "");
		else
			wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
				"status_code=%u%s%s%s",
				data->assoc_reject.status_code,
				data->assoc_reject.timed_out ? " timeout" : "",
				data->assoc_reject.timeout_reason ? "=" : "",
				data->assoc_reject.timeout_reason ?
				data->assoc_reject.timeout_reason : "");
		wpa_s->assoc_status_code = data->assoc_reject.status_code;
		wpa_s->assoc_timed_out = data->assoc_reject.timed_out;
		wpas_notify_assoc_status_code(wpa_s);
		if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
			sme_event_assoc_reject(wpa_s, data);
		else {
			const u8 *bssid = data->assoc_reject.bssid;

#ifdef CONFIG_FILS
			/* Update ERP next sequence number */
			if (wpa_s->auth_alg == WPA_AUTH_ALG_FILS)
				eapol_sm_update_erp_next_seq_num(
				      wpa_s->eapol,
				      data->assoc_reject.fils_erp_next_seq_num);
#endif /* CONFIG_FILS */

			if (bssid == NULL || is_zero_ether_addr(bssid))
				bssid = wpa_s->pending_bssid;
			wpas_connection_failed(wpa_s, bssid);
			wpa_supplicant_mark_disassoc(wpa_s);
		}
		break;

			wpas_connection_failed(wpa_s, bssid);
			wpa_supplicant_mark_disassoc(wpa_s);
}

external\wpa_supplicant_8\wpa_supplicant\wpa_supplicant.c
void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
{
	int timeout;
	int count;
	int *freqs = NULL;

	wpas_connect_work_done(wpa_s);

	/*
	 * Remove possible authentication timeout since the connection failed.
	 */
	eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);

	/*
	 * There is no point in blacklisting the AP if this event is
	 * generated based on local request to disconnect.
	 */
	if (wpa_s->own_disconnect_req) {
		wpa_s->own_disconnect_req = 0;
		wpa_dbg(wpa_s, MSG_DEBUG,
			"Ignore connection failure due to local request to disconnect");
		return;
	}
	if (wpa_s->disconnected) {
		wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
			"indication since interface has been put into "
			"disconnected state");
		return;
	}

	/*
	 * Add the failed BSSID into the blacklist and speed up next scan
	 * attempt if there could be other APs that could accept association.
	 * The current blacklist count indicates how many times we have tried
	 * connecting to this AP and multiple attempts mean that other APs are
	 * either not available or has already been tried, so that we can start
	 * increasing the delay here to avoid constant scanning.
	 */
	count = wpa_blacklist_add(wpa_s, bssid);		// 加入黑名单
	if (count == 1 && wpa_s->current_bss) {
		/*
		 * This BSS was not in the blacklist before. If there is
		 * another BSS available for the same ESS, we should try that
		 * next. Otherwise, we may as well try this one once more
		 * before allowing other, likely worse, ESSes to be considered.
		 */
		 // 一个ESS中有多个BSS，ssid都相同，由不同的AP组成，BSSID不同。
		 // 这个函数就是从BSS中找出其他频率,没有加入黑名单的BSSID来进行下一次扫描。
		freqs = get_bss_freqs_in_ess(wpa_s);
		if (freqs) {
			wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
				"has been seen; try it next");
			wpa_blacklist_add(wpa_s, bssid);
			/*
			 * On the next scan, go through only the known channels
			 * used in this ESS based on previous scans to speed up
			 * common load balancing use case.
			 */
			os_free(wpa_s->next_scan_freqs);
			// 下次扫描的频率
			wpa_s->next_scan_freqs = freqs;
		}
	}

	/*
	 * Add previous failure count in case the temporary blacklist was
	 * cleared due to no other BSSes being available.
	 */
	count += wpa_s->extra_blacklist_count;

	if (count > 3 && wpa_s->current_ssid) {
		wpa_printf(MSG_DEBUG, "Continuous association failures - "
			   "consider temporary network disabling");
		wpas_auth_failed(wpa_s, "CONN_FAILED");
	}

	switch (count) {
	case 1:
		timeout = 100;
		break;
	case 2:
		timeout = 500;
		break;
	case 3:
		timeout = 1000;
		break;
	case 4:
		timeout = 5000;
		break;
	default:
		timeout = 10000;
		break;
	}

	wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
		"ms", count, timeout);

	/*
	 * TODO: if more than one possible AP is available in scan results,
	 * could try the other ones before requesting a new scan.
	 */
	wpa_supplicant_req_scan(wpa_s, timeout / 1000,
				1000 * (timeout % 1000));
}

void wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s)
{
	int bssid_changed;

	wnm_bss_keep_alive_deinit(wpa_s);

#ifdef CONFIG_IBSS_RSN
	ibss_rsn_deinit(wpa_s->ibss_rsn);
	wpa_s->ibss_rsn = NULL;
#endif /* CONFIG_IBSS_RSN */

#ifdef CONFIG_AP
	wpa_supplicant_ap_deinit(wpa_s);
#endif /* CONFIG_AP */

#ifdef CONFIG_HS20
	/* Clear possibly configured frame filters */
	wpa_drv_configure_frame_filters(wpa_s, 0);
#endif /* CONFIG_HS20 */

	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
		return;
	// 更改wpa的状态。
	wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
	bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
	os_memset(wpa_s->bssid, 0, ETH_ALEN);
	os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
	sme_clear_on_disassoc(wpa_s);
	wpa_s->current_bss = NULL;
	wpa_s->assoc_freq = 0;

	if (bssid_changed)
		wpas_notify_bssid_changed(wpa_s);

	eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
	eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
	if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
	    wpa_s->key_mgmt == WPA_KEY_MGMT_OWE ||
	    wpa_s->key_mgmt == WPA_KEY_MGMT_DPP)
		eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
	wpa_s->ap_ies_from_associnfo = 0;
	wpa_s->current_ssid = NULL;
	eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
	wpa_s->key_mgmt = 0;

	wpas_rrm_reset(wpa_s);
	wpa_s->wnmsleep_used = 0;
}

external\wpa_supplicant_8\wpa_supplicant\wpa_supplicant.c
void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
			      enum wpa_states state)
{
	enum wpa_states old_state = wpa_s->wpa_state;
	                                        // 这里就是我们经常看到的log： wlan0: State: ASSOCIATING -> DISCONNECTED
	wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
		wpa_supplicant_state_txt(wpa_s->wpa_state),
		wpa_supplicant_state_txt(state));

	if (state == WPA_INTERFACE_DISABLED) {
		/* Assure normal scan when interface is restored */
		wpa_s->normal_scans = 0;
	}

	if (state == WPA_COMPLETED) {
		wpas_connect_work_done(wpa_s);
		/* Reinitialize normal_scan counter */
		wpa_s->normal_scans = 0;
	}

......

	if (state != WPA_SCANNING)
		wpa_supplicant_notify_scanning(wpa_s, 0);
	                                                                            // 如果是WPA_COMPLETED
	if (state == WPA_COMPLETED && wpa_s->new_connection) {
		struct wpa_ssid *ssid = wpa_s->current_ssid;
		int fils_hlp_sent = 0;

#ifdef CONFIG_SME
		if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
		    wpa_auth_alg_fils(wpa_s->sme.auth_alg))
			fils_hlp_sent = 1;
#endif /* CONFIG_SME */
		if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
		    wpa_auth_alg_fils(wpa_s->auth_alg))
			fils_hlp_sent = 1;

#if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
		wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
			MACSTR " completed [id=%d id_str=%s%s]",
			MAC2STR(wpa_s->bssid),
			ssid ? ssid->id : -1,
			ssid && ssid->id_str ? ssid->id_str : "",
			fils_hlp_sent ? " FILS_HLP_SENT" : "");
#endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
		wpas_clear_temp_disabled(wpa_s, ssid, 1);
		wpa_blacklist_clear(wpa_s);			// 连接上了，设备从黑名单移除
		wpa_s->extra_blacklist_count = 0;
		wpa_s->new_connection = 0;
		wpa_drv_set_operstate(wpa_s, 1);
#ifndef IEEE8021X_EAPOL
		wpa_drv_set_supp_port(wpa_s, 1);
#endif /* IEEE8021X_EAPOL */
		wpa_s->after_wps = 0;
		wpa_s->known_wps_freq = 0;
		wpas_p2p_completed(wpa_s);

		sme_sched_obss_scan(wpa_s, 1);

#if defined(CONFIG_FILS) && defined(IEEE8021X_EAPOL)
		if (!fils_hlp_sent && ssid && ssid->eap.erp)
			wpas_update_fils_connect_params(wpa_s);
#endif /* CONFIG_FILS && IEEE8021X_EAPOL */
	// disconnect 状态的处理
	} else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
		   state == WPA_ASSOCIATED) {
		wpa_s->new_connection = 1;
		wpa_drv_set_operstate(wpa_s, 0);
#ifndef IEEE8021X_EAPOL
		wpa_drv_set_supp_port(wpa_s, 0);
#endif /* IEEE8021X_EAPOL */
		sme_sched_obss_scan(wpa_s, 0);
	}
	wpa_s->wpa_state = state;

#ifdef CONFIG_BGSCAN
	if (state == WPA_COMPLETED)
		wpa_supplicant_start_bgscan(wpa_s);
	else if (state < WPA_ASSOCIATED)
		wpa_supplicant_stop_bgscan(wpa_s);
#endif /* CONFIG_BGSCAN */
#if 0 //qc_modify
	wpa_s->wapi_state = wpa_state_to_wapi_state(wpa_s->wpa_state);
	wpa_printf(MSG_DEBUG, "%s wapi_state : %d\n",__func__ ,wpa_s->wapi_state);
#endif
	if (state == WPA_AUTHENTICATING)
		wpa_supplicant_stop_autoscan(wpa_s);
	// 断开连接，进行自动扫描
	if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
		wpa_supplicant_start_autoscan(wpa_s);

	if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
		wmm_ac_notify_disassoc(wpa_s);

	if (wpa_s->wpa_state != old_state) {
		wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);

		/*
		 * Notify the P2P Device interface about a state change in one
		 * of the interfaces.
		 */
		wpas_p2p_indicate_state_change(wpa_s);

		if (wpa_s->wpa_state == WPA_COMPLETED ||
		    old_state == WPA_COMPLETED)
			wpas_notify_auth_changed(wpa_s);
	}
}

// 通知时间给上层
external\wpa_supplicant_8\wpa_supplicant\notify.c
void wpas_notify_state_changed(struct wpa_supplicant *wpa_s,
			       enum wpa_states new_state,
			       enum wpa_states old_state)
{
	if (wpa_s->p2p_mgmt)
		return;

	/* 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_FST
	if (wpa_s->fst && !is_zero_ether_addr(wpa_s->bssid)) {
		if (new_state == WPA_COMPLETED)
			fst_notify_peer_connected(wpa_s->fst, wpa_s->bssid);
		else if (old_state >= WPA_ASSOCIATED &&
			 new_state < WPA_ASSOCIATED)
			fst_notify_peer_disconnected(wpa_s->fst, wpa_s->bssid);
	}
#endif /* CONFIG_FST */

	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);

	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 */

	wpas_hidl_notify_state_changed(wpa_s);                // 发送给hidl
}

external\wpa_supplicant_8\wpa_supplicant\hidl\1.0\hidl.cpp
int wpas_hidl_notify_state_changed(struct wpa_supplicant *wpa_s)
{
	if (!wpa_s || !wpa_s->global->hidl)
		return 1;

	wpa_printf(
	    MSG_DEBUG, "Notifying state change event to hidl control: %s",
	    wpa_supplicant_state_txt(wpa_s->wpa_state));

	HidlManager *hidl_manager = HidlManager::getInstance();
	if (!hidl_manager)
		return 1;

	return hidl_manager->notifyStateChange(wpa_s);
}

external\wpa_supplicant_8\wpa_supplicant\hidl\1.0\hidl_manager.cpp
int HidlManager::notifyStateChange(struct wpa_supplicant *wpa_s)
{
	if (!wpa_s)
		return 1;

	if (sta_iface_object_map_.find(wpa_s->ifname) ==
	    sta_iface_object_map_.end())
		return 1;

	// Invoke the |onStateChanged| method on all registered callbacks.
	uint32_t hidl_network_id = UINT32_MAX;
	std::vector<uint8_t> hidl_ssid;
	if (wpa_s->current_ssid) {
		hidl_network_id = wpa_s->current_ssid->id;
		hidl_ssid.assign(
		    wpa_s->current_ssid->ssid,
		    wpa_s->current_ssid->ssid + wpa_s->current_ssid->ssid_len);
	}
	uint8_t *bssid;
	// wpa_supplicant sets the |pending_bssid| field when it starts a
	// connection. Only after association state does it update the |bssid|
	// field. So, in the HIDL callback send the appropriate bssid.
	if (wpa_s->wpa_state <= WPA_ASSOCIATED) {
		bssid = wpa_s->pending_bssid;
	} else {
		bssid = wpa_s->bssid;
	}
	bool fils_hlp_sent =
		(wpa_auth_alg_fils(wpa_s->auth_alg) &&
		 !dl_list_empty(&wpa_s->fils_hlp_req) &&
		 (wpa_s->wpa_state == WPA_COMPLETED)) ? true : false;

    // 回调函数
	if (checkForVendorStaIfaceCallback(wpa_s->ifname) == true) {
		callWithEachVendorStaIfaceCallback(
		    wpa_s->ifname, std::bind(
		       &ISupplicantVendorStaIfaceCallback::onVendorStateChanged,
		       std::placeholders::_1,
		       static_cast<ISupplicantStaIfaceCallback::State>(
		       wpa_s->wpa_state),
		       bssid, hidl_network_id, hidl_ssid, fils_hlp_sent));
	} else {
		callWithEachStaIfaceCallback(
		    wpa_s->ifname, std::bind(
			&ISupplicantStaIfaceCallback::onStateChanged,
			std::placeholders::_1,
			static_cast<ISupplicantStaIfaceCallback::State>(
			wpa_s->wpa_state),
			bssid, hidl_network_id, hidl_ssid));
	}

	return 0;
}

frameworks\opt\net\wifi\service\java\com\android\server\wifi\SupplicantStaIfaceHal.java
   private class SupplicantVendorStaIfaceHalCallback extends ISupplicantVendorStaIfaceCallback.Stub {

          @Override
        public void onAssociationRejected(byte[/* 6 */] bssid, int statusCode, boolean timedOut) {
            synchronized (mLock) {
                logCallback("onAssociationRejected");
                mWifiMonitor.broadcastAssociationRejectionEvent(mIfaceName, statusCode, timedOut,
                        NativeUtil.macAddressFromByteArray(bssid));
            }
        }

	// 发送消息给WifiStateMachine
frameworks\opt\net\wifi\service\java\com\android\server\wifi\WifiMonitor.java
    public void broadcastAssociationRejectionEvent(String iface, int status, boolean timedOut,
                                                   String bssid) {
        sendMessage(iface, ASSOCIATION_REJECTION_EVENT, timedOut ? 1 : 0, status, bssid);
    }

frameworks\opt\net\wifi\service\java\com\android\server\wifi\WifiStateMachine.java
	        public boolean processMessage(Message message) {
            WifiConfiguration config;
            int netId;
            boolean ok;
            boolean didDisconnect;
            String bssid;
            String ssid;
            NetworkUpdateResult result;
            Set<Integer> removedNetworkIds;
            int reasonCode;
            boolean timedOut;
            logStateAndMessage(message, this);

            switch (message.what) {
                case WifiMonitor.ASSOCIATION_REJECTION_EVENT:
                    mWifiDiagnostics.captureBugReportData(
                            WifiDiagnostics.REPORT_REASON_ASSOC_FAILURE);
                    didBlackListBSSID = false;
                    bssid = (String) message.obj;
                    timedOut = message.arg1 > 0;
                    reasonCode = message.arg2;
                    Log.d(TAG, "Assocation Rejection event: bssid=" + bssid + " reason code="
                            + reasonCode + " timedOut=" + Boolean.toString(timedOut));
                    if (bssid == null || TextUtils.isEmpty(bssid)) {
                        // If BSSID is null, use the target roam BSSID
                        bssid = mTargetRoamBSSID;
                    }
                    if (bssid != null) {
                        // If we have a BSSID, tell configStore to black list it
                        didBlackListBSSID = mWifiConnectivityManager.trackBssid(bssid, false,
                            reasonCode);
                    }
                    // 根据reason code更新状态
                    mWifiConfigManager.updateNetworkSelectionStatus(mTargetNetworkId,
                            WifiConfiguration.NetworkSelectionStatus
                            .DISABLED_ASSOCIATION_REJECTION);
                    mWifiConfigManager.setRecentFailureAssociationStatus(mTargetNetworkId,
                            reasonCode);
                    mSupplicantStateTracker.sendMessage(WifiMonitor.ASSOCIATION_REJECTION_EVENT);
                    // If rejection occurred while Metrics is tracking a ConnnectionEvent, end it.
                    reportConnectionAttemptEnd(
                            WifiMetrics.ConnectionEvent.FAILURE_ASSOCIATION_REJECTION,
                            WifiMetricsProto.ConnectionEvent.HLF_NONE);
                    mWifiInjector.getWifiLastResortWatchdog()
                            .noteConnectionFailureAndTriggerIfNeeded(
                                    getTargetSsid(), bssid,
                                    WifiLastResortWatchdog.FAILURE_CODE_ASSOCIATION);
                    break;

public boolean trackBssid(String bssid, boolean enable, int reasonCode) {
        localLog("trackBssid: " + (enable ? "enable " : "disable ") + bssid + " reason code "
                + reasonCode);

        if (bssid == null) {
            return false;
        }
                    // 加入黑名单
        if (!updateBssidBlacklist(bssid, enable, reasonCode)) {
            return false;
        }

        // Blacklist was updated, so update firmware roaming configuration.
        updateFirmwareRoamingConfiguration();
                // 立即扫描
        if (!enable) {
            // Disabling a BSSID can happen when connection to the AP was rejected.
            // We start another scan immediately so that WifiNetworkSelector can
            // give us another candidate to connect to.
            startConnectivityScan(SCAN_IMMEDIATELY);
        }

        return true;
    }