| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.server.wifi; |
| |
| import static com.android.internal.util.Preconditions.checkNotNull; |
| import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_LOCAL_ONLY; |
| import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_PRIMARY; |
| import static com.android.server.wifi.util.NativeUtil.addEnclosingQuotes; |
| |
| import static java.lang.Math.toIntExact; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.app.ActivityManager; |
| import android.app.AlarmManager; |
| import android.app.AppOpsManager; |
| import android.companion.CompanionDeviceManager; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.net.MacAddress; |
| import android.net.NetworkCapabilities; |
| import android.net.NetworkFactory; |
| import android.net.NetworkRequest; |
| import android.net.NetworkSpecifier; |
| import android.net.wifi.IActionListener; |
| import android.net.wifi.INetworkRequestMatchCallback; |
| import android.net.wifi.INetworkRequestUserSelectionCallback; |
| import android.net.wifi.ScanResult; |
| import android.net.wifi.SecurityParams; |
| import android.net.wifi.WifiConfiguration; |
| import android.net.wifi.WifiConfiguration.SecurityType; |
| import android.net.wifi.WifiNetworkSpecifier; |
| import android.net.wifi.WifiScanner; |
| import android.os.Handler; |
| import android.os.HandlerExecutor; |
| import android.os.Looper; |
| import android.os.PatternMatcher; |
| import android.os.PowerManager; |
| import android.os.Process; |
| import android.os.RemoteCallbackList; |
| import android.os.RemoteException; |
| import android.os.UserHandle; |
| import android.os.WorkSource; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.util.Pair; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.server.wifi.proto.nano.WifiMetricsProto; |
| import com.android.server.wifi.util.ActionListenerWrapper; |
| import com.android.server.wifi.util.ScanResultUtil; |
| import com.android.server.wifi.util.WifiPermissionsUtil; |
| import com.android.wifi.resources.R; |
| |
| import java.io.FileDescriptor; |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.concurrent.TimeUnit; |
| import java.util.stream.Collectors; |
| |
| /** |
| * Network factory to handle trusted wifi network requests. |
| */ |
| public class WifiNetworkFactory extends NetworkFactory { |
| private static final String TAG = "WifiNetworkFactory"; |
| @VisibleForTesting |
| private static final int SCORE_FILTER = 60; |
| @VisibleForTesting |
| public static final int CACHED_SCAN_RESULTS_MAX_AGE_IN_MILLIS = 30 * 1000; |
| @VisibleForTesting |
| public static final int PERIODIC_SCAN_INTERVAL_MS = 10 * 1000; // 10 seconds |
| @VisibleForTesting |
| public static final int NETWORK_CONNECTION_TIMEOUT_MS = 30 * 1000; // 30 seconds |
| @VisibleForTesting |
| public static final int USER_SELECTED_NETWORK_CONNECT_RETRY_MAX = 3; // max of 3 retries. |
| @VisibleForTesting |
| public static final String UI_START_INTENT_ACTION = |
| "com.android.settings.wifi.action.NETWORK_REQUEST"; |
| @VisibleForTesting |
| public static final String UI_START_INTENT_CATEGORY = "android.intent.category.DEFAULT"; |
| @VisibleForTesting |
| public static final String UI_START_INTENT_EXTRA_APP_NAME = |
| "com.android.settings.wifi.extra.APP_NAME"; |
| @VisibleForTesting |
| public static final String UI_START_INTENT_EXTRA_REQUEST_IS_FOR_SINGLE_NETWORK = |
| "com.android.settings.wifi.extra.REQUEST_IS_FOR_SINGLE_NETWORK"; |
| // Capacity limit of approved Access Point per App |
| @VisibleForTesting |
| public static final int NUM_OF_ACCESS_POINT_LIMIT_PER_APP = 50; |
| |
| private final Context mContext; |
| private final ActivityManager mActivityManager; |
| private final AlarmManager mAlarmManager; |
| private final AppOpsManager mAppOpsManager; |
| private final Clock mClock; |
| private final Handler mHandler; |
| private final WifiInjector mWifiInjector; |
| private final WifiConnectivityManager mWifiConnectivityManager; |
| private final WifiConfigManager mWifiConfigManager; |
| private final WifiConfigStore mWifiConfigStore; |
| private final WifiPermissionsUtil mWifiPermissionsUtil; |
| private final WifiMetrics mWifiMetrics; |
| private final ActiveModeWarden mActiveModeWarden; |
| private final WifiScanner.ScanSettings mScanSettings; |
| private final NetworkFactoryScanListener mScanListener; |
| private final PeriodicScanAlarmListener mPeriodicScanTimerListener; |
| private final ConnectionTimeoutAlarmListener mConnectionTimeoutAlarmListener; |
| private final ConnectHelper mConnectHelper; |
| private final ClientModeImplMonitor mClientModeImplMonitor; |
| private RemoteCallbackList<INetworkRequestMatchCallback> mRegisteredCallbacks; |
| // Store all user approved access points for apps. |
| @VisibleForTesting |
| public final Map<String, LinkedHashSet<AccessPoint>> mUserApprovedAccessPointMap; |
| private WifiScanner mWifiScanner; |
| @Nullable private ClientModeManager mClientModeManager; |
| @Nullable private ActiveModeManager.ClientRole mClientModeManagerRole; |
| private CompanionDeviceManager mCompanionDeviceManager; |
| // Temporary approval set by shell commands. |
| @Nullable private String mApprovedApp = null; |
| |
| private int mGenericConnectionReqCount = 0; |
| // Request that is being actively processed. All new requests start out as an "active" request |
| // because we're processing it & handling all the user interactions associated with it. Once we |
| // successfully connect to the network, we transition that request to "connected". |
| @Nullable private NetworkRequest mActiveSpecificNetworkRequest; |
| @Nullable private WifiNetworkSpecifier mActiveSpecificNetworkRequestSpecifier; |
| // Request corresponding to the the network that the device is currently connected to. |
| @Nullable private NetworkRequest mConnectedSpecificNetworkRequest; |
| @Nullable private WifiNetworkSpecifier mConnectedSpecificNetworkRequestSpecifier; |
| @Nullable private WifiConfiguration mUserSelectedNetwork; |
| private int mUserSelectedNetworkConnectRetryCount; |
| // Map of bssid to latest scan results for all scan results matching a request. Will be |
| // - null, if there are no active requests. |
| // - empty, if there are no matching scan results received for the active request. |
| @Nullable private Map<String, ScanResult> mActiveMatchedScanResults; |
| /** Connection start time to keep track of connection duration */ |
| private long mConnectionStartTimeMillis = -1L; |
| /** |
| * CMI listener used for concurrent connection metrics collection. |
| * Not used when the connection is on primary STA (i.e not STA + STA). |
| */ |
| @Nullable private CmiListener mCmiListener; |
| // Verbose logging flag. |
| private boolean mVerboseLoggingEnabled = false; |
| private boolean mPeriodicScanTimerSet = false; |
| private boolean mConnectionTimeoutSet = false; |
| private boolean mIsPeriodicScanEnabled = false; |
| private boolean mIsPeriodicScanPaused = false; |
| // We sent a new connection request and are waiting for connection success. |
| private boolean mPendingConnectionSuccess = false; |
| /** |
| * Indicates that we have new data to serialize. |
| */ |
| private boolean mHasNewDataToSerialize = false; |
| |
| /** |
| * Helper class to store an access point that the user previously approved for a specific app. |
| * TODO(b/123014687): Move to a common util class. |
| */ |
| public static class AccessPoint { |
| public final String ssid; |
| public final MacAddress bssid; |
| public final @SecurityType int networkType; |
| |
| AccessPoint(@NonNull String ssid, @NonNull MacAddress bssid, |
| @SecurityType int networkType) { |
| this.ssid = ssid; |
| this.bssid = bssid; |
| this.networkType = networkType; |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash(ssid, bssid, networkType); |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| if (!(obj instanceof AccessPoint)) { |
| return false; |
| } |
| AccessPoint other = (AccessPoint) obj; |
| return TextUtils.equals(this.ssid, other.ssid) |
| && Objects.equals(this.bssid, other.bssid) |
| && this.networkType == other.networkType; |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder("AccessPoint: "); |
| return sb.append(ssid) |
| .append(", ") |
| .append(bssid) |
| .append(", ") |
| .append(networkType) |
| .toString(); |
| } |
| } |
| |
| // Scan listener for scan requests. |
| private class NetworkFactoryScanListener implements WifiScanner.ScanListener { |
| @Override |
| public void onSuccess() { |
| // Scan request succeeded, wait for results to report to external clients. |
| if (mVerboseLoggingEnabled) { |
| Log.d(TAG, "Scan request succeeded"); |
| } |
| } |
| |
| @Override |
| public void onFailure(int reason, String description) { |
| Log.e(TAG, "Scan failure received. reason: " + reason |
| + ", description: " + description); |
| // TODO(b/113878056): Retry scan to workaround any transient scan failures. |
| scheduleNextPeriodicScan(); |
| } |
| |
| @Override |
| public void onResults(WifiScanner.ScanData[] scanDatas) { |
| if (mVerboseLoggingEnabled) { |
| Log.d(TAG, "Scan results received"); |
| } |
| // For single scans, the array size should always be 1. |
| if (scanDatas.length != 1) { |
| Log.wtf(TAG, "Found more than 1 batch of scan results, Ignoring..."); |
| return; |
| } |
| WifiScanner.ScanData scanData = scanDatas[0]; |
| ScanResult[] scanResults = scanData.getResults(); |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Received " + scanResults.length + " scan results"); |
| } |
| handleScanResults(scanResults); |
| if (mActiveMatchedScanResults != null) { |
| sendNetworkRequestMatchCallbacksForActiveRequest( |
| mActiveMatchedScanResults.values()); |
| } |
| scheduleNextPeriodicScan(); |
| } |
| |
| @Override |
| public void onFullResult(ScanResult fullScanResult) { |
| // Ignore for single scans. |
| } |
| |
| @Override |
| public void onPeriodChanged(int periodInMs) { |
| // Ignore for single scans. |
| } |
| }; |
| |
| private class PeriodicScanAlarmListener implements AlarmManager.OnAlarmListener { |
| @Override |
| public void onAlarm() { |
| // Trigger the next scan. |
| startScan(); |
| mPeriodicScanTimerSet = false; |
| } |
| } |
| |
| private class ConnectionTimeoutAlarmListener implements AlarmManager.OnAlarmListener { |
| @Override |
| public void onAlarm() { |
| Log.e(TAG, "Timed-out connecting to network"); |
| handleNetworkConnectionFailure(mUserSelectedNetwork, mUserSelectedNetwork.BSSID); |
| mConnectionTimeoutSet = false; |
| } |
| } |
| |
| // Callback result from settings UI. |
| private class NetworkFactoryUserSelectionCallback extends |
| INetworkRequestUserSelectionCallback.Stub { |
| private final NetworkRequest mNetworkRequest; |
| |
| NetworkFactoryUserSelectionCallback(NetworkRequest networkRequest) { |
| mNetworkRequest = networkRequest; |
| } |
| |
| @Override |
| public void select(WifiConfiguration wifiConfiguration) { |
| mHandler.post(() -> { |
| if (mActiveSpecificNetworkRequest != mNetworkRequest) { |
| Log.e(TAG, "Stale callback select received"); |
| return; |
| } |
| handleConnectToNetworkUserSelection(wifiConfiguration); |
| }); |
| } |
| |
| @Override |
| public void reject() { |
| mHandler.post(() -> { |
| if (mActiveSpecificNetworkRequest != mNetworkRequest) { |
| Log.e(TAG, "Stale callback reject received"); |
| return; |
| } |
| handleRejectUserSelection(); |
| }); |
| } |
| } |
| |
| private final class ConnectActionListener extends IActionListener.Stub { |
| @Override |
| public void onSuccess() { |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Triggered network connection"); |
| } |
| } |
| |
| @Override |
| public void onFailure(int reason) { |
| Log.e(TAG, "Failed to trigger network connection"); |
| handleNetworkConnectionFailure(mUserSelectedNetwork, mUserSelectedNetwork.BSSID); |
| } |
| } |
| |
| private final class ClientModeManagerRequestListener implements |
| ActiveModeWarden.ExternalClientModeManagerRequestListener { |
| @Override |
| public void onAnswer(@Nullable ClientModeManager modeManager) { |
| if (modeManager != null) { |
| // Remove the mode manager if the associated request is no longer active. |
| if (mActiveSpecificNetworkRequest == null |
| && mConnectedSpecificNetworkRequest == null) { |
| Log.w(TAG, "Client mode manager request answer received with no active" |
| + " requests"); |
| mActiveModeWarden.removeClientModeManager(modeManager); |
| return; |
| } |
| mClientModeManager = modeManager; |
| mClientModeManagerRole = modeManager.getRole(); |
| handleClientModeManagerRetrieval(); |
| } else { |
| handleClientModeManagerRemovalOrFailure(); |
| } |
| } |
| } |
| |
| private class ModeChangeCallback implements ActiveModeWarden.ModeChangeCallback { |
| @Override |
| public void onActiveModeManagerAdded(@NonNull ActiveModeManager activeModeManager) { |
| // ignored. |
| // Will get a dedicated ClientModeManager instance for our request via |
| // ClientModeManagerRequestListener. |
| } |
| |
| @Override |
| public void onActiveModeManagerRemoved(@NonNull ActiveModeManager activeModeManager) { |
| if (!(activeModeManager instanceof ClientModeManager)) return; |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "ModeManager removed " + activeModeManager.getInterfaceName()); |
| } |
| // Mode manager removed. Cleanup any ongoing requests. |
| if (activeModeManager == mClientModeManager |
| || !mActiveModeWarden.hasPrimaryClientModeManager()) { |
| handleClientModeManagerRemovalOrFailure(); |
| } |
| } |
| |
| @Override |
| public void onActiveModeManagerRoleChanged(@NonNull ActiveModeManager activeModeManager) { |
| if (!(activeModeManager instanceof ClientModeManager)) return; |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "ModeManager role changed " + activeModeManager.getInterfaceName()); |
| } |
| // Mode manager role changed. Cleanup any ongoing requests. |
| if (activeModeManager == mClientModeManager |
| || !mActiveModeWarden.hasPrimaryClientModeManager()) { |
| handleClientModeManagerRemovalOrFailure(); |
| } |
| } |
| } |
| |
| /** |
| * Module to interact with the wifi config store. |
| */ |
| private class NetworkRequestDataSource implements NetworkRequestStoreData.DataSource { |
| @Override |
| public Map<String, Set<AccessPoint>> toSerialize() { |
| // Clear the flag after writing to disk. |
| mHasNewDataToSerialize = false; |
| return new HashMap<>(mUserApprovedAccessPointMap); |
| } |
| |
| @Override |
| public void fromDeserialized(Map<String, Set<AccessPoint>> approvedAccessPointMap) { |
| approvedAccessPointMap.forEach((key, value) -> |
| mUserApprovedAccessPointMap.put(key, new LinkedHashSet<>(value))); |
| } |
| |
| @Override |
| public void reset() { |
| mUserApprovedAccessPointMap.clear(); |
| } |
| |
| @Override |
| public boolean hasNewDataToSerialize() { |
| return mHasNewDataToSerialize; |
| } |
| } |
| |
| /** |
| * To keep track of concurrent connections using this API surface (for metrics collection only). |
| * |
| * Only used if the connection is initiated on secondary STA. |
| */ |
| private class CmiListener implements ClientModeImplListener { |
| /** Concurrent connection start time to keep track of connection duration */ |
| private long mConcurrentConnectionStartTimeMillis = -1L; |
| /** Whether we have already indicated the presence of concurrent connection */ |
| private boolean mHasAlreadyIncrementedConcurrentConnectionCount = false; |
| |
| private boolean isLocalOnlyOrPrimary(@NonNull ClientModeManager cmm) { |
| return cmm.getRole() == ROLE_CLIENT_PRIMARY |
| || cmm.getRole() == ROLE_CLIENT_LOCAL_ONLY; |
| } |
| |
| private void checkForConcurrencyStartAndIncrementMetrics() { |
| int numLocalOnlyOrPrimaryConnectedCmms = 0; |
| for (ClientModeManager cmm : mActiveModeWarden.getClientModeManagers()) { |
| if (isLocalOnlyOrPrimary(cmm) && cmm.isConnected()) { |
| numLocalOnlyOrPrimaryConnectedCmms++; |
| } |
| } |
| if (numLocalOnlyOrPrimaryConnectedCmms > 1) { |
| mConcurrentConnectionStartTimeMillis = mClock.getElapsedSinceBootMillis(); |
| // Note: We could have multiple connect/disconnect of the primary connection |
| // while remaining connected to the local only connection. We want to keep track |
| // of the connection durations accurately across those disconnects. However, we do |
| // not want to increment the connection count metric since that should be a 1:1 |
| // mapping with the number of requests processed (i.e don't indicate 2 concurrent |
| // connection count if the primary disconnected & connected back while processing |
| // the same local only request). |
| if (!mHasAlreadyIncrementedConcurrentConnectionCount) { |
| mWifiMetrics.incrementNetworkRequestApiNumConcurrentConnection(); |
| mHasAlreadyIncrementedConcurrentConnectionCount = true; |
| } |
| } |
| } |
| |
| public void checkForConcurrencyEndAndIncrementMetrics() { |
| if (mConcurrentConnectionStartTimeMillis != -1L) { |
| mWifiMetrics.incrementNetworkRequestApiConcurrentConnectionDurationSecHistogram( |
| toIntExact(TimeUnit.MILLISECONDS.toSeconds( |
| mClock.getElapsedSinceBootMillis() |
| - mConcurrentConnectionStartTimeMillis))); |
| mConcurrentConnectionStartTimeMillis = -1L; |
| } |
| } |
| |
| CmiListener() { |
| checkForConcurrencyStartAndIncrementMetrics(); |
| } |
| |
| @Override |
| public void onL3Connected(@NonNull ConcreteClientModeManager clientModeManager) { |
| if (isLocalOnlyOrPrimary(clientModeManager)) { |
| checkForConcurrencyStartAndIncrementMetrics(); |
| } |
| } |
| |
| @Override |
| public void onConnectionEnd(@NonNull ConcreteClientModeManager clientModeManager) { |
| if (isLocalOnlyOrPrimary(clientModeManager)) { |
| checkForConcurrencyEndAndIncrementMetrics(); |
| } |
| } |
| } |
| |
| public WifiNetworkFactory(Looper looper, Context context, NetworkCapabilities nc, |
| ActivityManager activityManager, AlarmManager alarmManager, |
| AppOpsManager appOpsManager, |
| Clock clock, WifiInjector wifiInjector, |
| WifiConnectivityManager connectivityManager, |
| WifiConfigManager configManager, |
| WifiConfigStore configStore, |
| WifiPermissionsUtil wifiPermissionsUtil, |
| WifiMetrics wifiMetrics, |
| ActiveModeWarden activeModeWarden, |
| ConnectHelper connectHelper, |
| ClientModeImplMonitor clientModeImplMonitor) { |
| super(looper, context, TAG, nc); |
| mContext = context; |
| mActivityManager = activityManager; |
| mAlarmManager = alarmManager; |
| mAppOpsManager = appOpsManager; |
| mClock = clock; |
| mHandler = new Handler(looper); |
| mWifiInjector = wifiInjector; |
| mWifiConnectivityManager = connectivityManager; |
| mWifiConfigManager = configManager; |
| mWifiConfigStore = configStore; |
| mWifiPermissionsUtil = wifiPermissionsUtil; |
| mWifiMetrics = wifiMetrics; |
| mActiveModeWarden = activeModeWarden; |
| mConnectHelper = connectHelper; |
| mClientModeImplMonitor = clientModeImplMonitor; |
| // Create the scan settings. |
| mScanSettings = new WifiScanner.ScanSettings(); |
| mScanSettings.type = WifiScanner.SCAN_TYPE_HIGH_ACCURACY; |
| mScanSettings.band = WifiScanner.WIFI_BAND_ALL; |
| mScanSettings.reportEvents = WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN; |
| mScanListener = new NetworkFactoryScanListener(); |
| mPeriodicScanTimerListener = new PeriodicScanAlarmListener(); |
| mConnectionTimeoutAlarmListener = new ConnectionTimeoutAlarmListener(); |
| mUserApprovedAccessPointMap = new HashMap<>(); |
| |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(Intent.ACTION_SCREEN_ON); |
| filter.addAction(Intent.ACTION_SCREEN_OFF); |
| context.registerReceiver( |
| new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(Intent.ACTION_SCREEN_ON)) { |
| handleScreenStateChanged(true); |
| } else if (action.equals(Intent.ACTION_SCREEN_OFF)) { |
| handleScreenStateChanged(false); |
| } |
| } |
| }, filter, null, mHandler); |
| handleScreenStateChanged(context.getSystemService(PowerManager.class).isInteractive()); |
| |
| // register the data store for serializing/deserializing data. |
| configStore.registerStoreData( |
| wifiInjector.makeNetworkRequestStoreData(new NetworkRequestDataSource())); |
| |
| activeModeWarden.registerModeChangeCallback(new ModeChangeCallback()); |
| |
| setScoreFilter(SCORE_FILTER); |
| } |
| |
| private void saveToStore() { |
| // Set the flag to let WifiConfigStore that we have new data to write. |
| mHasNewDataToSerialize = true; |
| if (!mWifiConfigManager.saveToStore(true)) { |
| Log.w(TAG, "Failed to save to store"); |
| } |
| } |
| |
| /** |
| * Enable verbose logging. |
| */ |
| public void enableVerboseLogging(boolean verbose) { |
| mVerboseLoggingEnabled = verbose; |
| } |
| |
| /** |
| * Add a new callback for network request match handling. |
| */ |
| public void addCallback(INetworkRequestMatchCallback callback) { |
| if (mActiveSpecificNetworkRequest == null) { |
| Log.wtf(TAG, "No valid network request. Ignoring callback registration"); |
| try { |
| callback.onAbort(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Unable to invoke network request abort callback " + callback, e); |
| } |
| return; |
| } |
| if (mRegisteredCallbacks == null) { |
| mRegisteredCallbacks = new RemoteCallbackList<>(); |
| } |
| if (!mRegisteredCallbacks.register(callback)) { |
| Log.e(TAG, "Failed to add callback"); |
| return; |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Adding callback. Num callbacks: " |
| + mRegisteredCallbacks.getRegisteredCallbackCount()); |
| } |
| // Register our user selection callback. |
| try { |
| callback.onUserSelectionCallbackRegistration( |
| new NetworkFactoryUserSelectionCallback(mActiveSpecificNetworkRequest)); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Unable to invoke user selection registration callback " + callback, e); |
| return; |
| } |
| |
| // If we are already in the midst of processing a request, send matching callbacks |
| // immediately on registering the callback. |
| if (mActiveMatchedScanResults != null) { |
| sendNetworkRequestMatchCallbacksForActiveRequest( |
| mActiveMatchedScanResults.values()); |
| } |
| } |
| |
| /** |
| * Remove an existing callback for network request match handling. |
| */ |
| public void removeCallback(INetworkRequestMatchCallback callback) { |
| if (mRegisteredCallbacks == null) return; |
| mRegisteredCallbacks.unregister(callback); |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Removing callback. Num callbacks: " |
| + mRegisteredCallbacks.getRegisteredCallbackCount()); |
| } |
| } |
| |
| private boolean canNewRequestOverrideExistingRequest( |
| NetworkRequest newRequest, NetworkRequest existingRequest) { |
| if (existingRequest == null) return true; |
| // Request from app with NETWORK_SETTINGS can override any existing requests. |
| if (mWifiPermissionsUtil.checkNetworkSettingsPermission(newRequest.getRequestorUid())) { |
| return true; |
| } |
| // Request from fg app can override any existing requests. |
| if (isRequestFromForegroundApp(newRequest.getRequestorPackageName())) return true; |
| // Request from fg service can override only if the existing request is not from a fg app. |
| if (!isRequestFromForegroundApp(existingRequest.getRequestorPackageName())) return true; |
| Log.e(TAG, "Already processing request from a foreground app " |
| + existingRequest.getRequestorPackageName() + ". Rejecting request from " |
| + newRequest.getRequestorPackageName()); |
| return false; |
| } |
| |
| boolean isRequestWithWifiNetworkSpecifierValid(NetworkRequest networkRequest) { |
| // Request cannot have internet capability since such a request can never be fulfilled. |
| // (NetworkAgent for connection with WifiNetworkSpecifier will not have internet capability) |
| if (networkRequest.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) { |
| Log.e(TAG, "Request with wifi network specifier cannot contain " |
| + "NET_CAPABILITY_INTERNET. Rejecting"); |
| return false; |
| } |
| if (networkRequest.getRequestorUid() == Process.INVALID_UID) { |
| Log.e(TAG, "Request with wifi network specifier should contain valid uid. Rejecting"); |
| return false; |
| } |
| if (TextUtils.isEmpty(networkRequest.getRequestorPackageName())) { |
| Log.e(TAG, "Request with wifi network specifier should contain valid package name." |
| + "Rejecting"); |
| return false; |
| } |
| try { |
| mAppOpsManager.checkPackage( |
| networkRequest.getRequestorUid(), networkRequest.getRequestorPackageName()); |
| } catch (SecurityException e) { |
| Log.e(TAG, "Invalid uid/package name " + networkRequest.getRequestorUid() + ", " |
| + networkRequest.getRequestorPackageName() + ". Rejecting", e); |
| return false; |
| } |
| WifiNetworkSpecifier wns = (WifiNetworkSpecifier) networkRequest.getNetworkSpecifier(); |
| if (wns.getBand() != ScanResult.UNSPECIFIED) { |
| Log.e(TAG, "Requesting specific frequency bands is not yet supported. Rejecting"); |
| return false; |
| } |
| if (!WifiConfigurationUtil.validateNetworkSpecifier(wns)) { |
| Log.e(TAG, "Invalid wifi network specifier: " + wns + ". Rejecting "); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Check whether to accept the new network connection request. |
| * |
| * All the validation of the incoming request is done in this method. |
| */ |
| @Override |
| public boolean acceptRequest(NetworkRequest networkRequest) { |
| NetworkSpecifier ns = networkRequest.getNetworkSpecifier(); |
| if (ns == null) { |
| // Generic wifi request. Always accept. |
| } else { |
| // Unsupported network specifier. |
| if (!(ns instanceof WifiNetworkSpecifier)) { |
| Log.e(TAG, "Unsupported network specifier: " + ns + ". Rejecting"); |
| return false; |
| } |
| // Invalid request with wifi network specifier. |
| if (!isRequestWithWifiNetworkSpecifierValid(networkRequest)) { |
| releaseRequestAsUnfulfillableByAnyFactory(networkRequest); |
| return false; |
| } |
| if (Objects.equals(mActiveSpecificNetworkRequest, networkRequest) |
| || Objects.equals(mConnectedSpecificNetworkRequest, networkRequest)) { |
| Log.e(TAG, "acceptRequest: Already processing the request " + networkRequest); |
| return true; |
| } |
| // Only allow specific wifi network request from foreground app/service. |
| if (!mWifiPermissionsUtil.checkNetworkSettingsPermission( |
| networkRequest.getRequestorUid()) |
| && !isRequestFromForegroundAppOrService( |
| networkRequest.getRequestorPackageName())) { |
| Log.e(TAG, "Request not from foreground app or service." |
| + " Rejecting request from " + networkRequest.getRequestorPackageName()); |
| releaseRequestAsUnfulfillableByAnyFactory(networkRequest); |
| return false; |
| } |
| // If there is an active request, only proceed if the new request is from a foreground |
| // app. |
| if (!canNewRequestOverrideExistingRequest( |
| networkRequest, mActiveSpecificNetworkRequest)) { |
| Log.e(TAG, "Request cannot override active request." |
| + " Rejecting request from " + networkRequest.getRequestorPackageName()); |
| releaseRequestAsUnfulfillableByAnyFactory(networkRequest); |
| return false; |
| } |
| // If there is a connected request, only proceed if the new request is from a foreground |
| // app. |
| if (!canNewRequestOverrideExistingRequest( |
| networkRequest, mConnectedSpecificNetworkRequest)) { |
| Log.e(TAG, "Request cannot override connected request." |
| + " Rejecting request from " + networkRequest.getRequestorPackageName()); |
| releaseRequestAsUnfulfillableByAnyFactory(networkRequest); |
| return false; |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Accepted network request with specifier from fg " |
| + (isRequestFromForegroundApp(networkRequest.getRequestorPackageName()) |
| ? "app" : "service")); |
| } |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Accepted network request " + networkRequest); |
| } |
| return true; |
| } |
| |
| /** |
| * Handle new network connection requests. |
| * |
| * The assumption here is that {@link #acceptRequest(NetworkRequest)} has already sanitized |
| * the incoming request. |
| */ |
| @Override |
| protected void needNetworkFor(NetworkRequest networkRequest) { |
| NetworkSpecifier ns = networkRequest.getNetworkSpecifier(); |
| if (ns == null) { |
| // Generic wifi request. Turn on auto-join if necessary. |
| if (++mGenericConnectionReqCount == 1) { |
| mWifiConnectivityManager.setTrustedConnectionAllowed(true); |
| } |
| } else { |
| // Unsupported network specifier. |
| if (!(ns instanceof WifiNetworkSpecifier)) { |
| Log.e(TAG, "Unsupported network specifier: " + ns + ". Ignoring"); |
| return; |
| } |
| // Invalid request with wifi network specifier. |
| if (!isRequestWithWifiNetworkSpecifierValid(networkRequest)) { |
| releaseRequestAsUnfulfillableByAnyFactory(networkRequest); |
| return; |
| } |
| // Wifi-off abort early. |
| if (!mActiveModeWarden.hasPrimaryClientModeManager()) { |
| Log.e(TAG, "Request with wifi network specifier when wifi is off." |
| + "Rejecting"); |
| releaseRequestAsUnfulfillableByAnyFactory(networkRequest); |
| return; |
| } |
| if (Objects.equals(mActiveSpecificNetworkRequest, networkRequest) |
| || Objects.equals(mConnectedSpecificNetworkRequest, networkRequest)) { |
| Log.e(TAG, "needNetworkFor: Already processing the request " + networkRequest); |
| return; |
| } |
| |
| retrieveWifiScanner(); |
| // Reset state from any previous request. |
| setupForActiveRequest(); |
| // Store the active network request. |
| mActiveSpecificNetworkRequest = networkRequest; |
| WifiNetworkSpecifier wns = (WifiNetworkSpecifier) ns; |
| mActiveSpecificNetworkRequestSpecifier = new WifiNetworkSpecifier( |
| wns.ssidPatternMatcher, wns.bssidPatternMatcher, ScanResult.UNSPECIFIED, |
| wns.wifiConfiguration); |
| mWifiMetrics.incrementNetworkRequestApiNumRequest(); |
| |
| if (!triggerConnectIfUserApprovedMatchFound()) { |
| // Start UI to let the user grant/disallow this request from the app. |
| startUi(); |
| // Didn't find an approved match, send the matching results to UI and trigger |
| // periodic scans for finding a network in the request. |
| // Fetch the latest cached scan results to speed up network matching. |
| ScanResult[] cachedScanResults = getFilteredCachedScanResults(); |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Using cached " + cachedScanResults.length + " scan results"); |
| } |
| handleScanResults(cachedScanResults); |
| if (mActiveMatchedScanResults != null) { |
| sendNetworkRequestMatchCallbacksForActiveRequest( |
| mActiveMatchedScanResults.values()); |
| } |
| startPeriodicScans(); |
| } |
| } |
| } |
| |
| @Override |
| protected void releaseNetworkFor(NetworkRequest networkRequest) { |
| NetworkSpecifier ns = networkRequest.getNetworkSpecifier(); |
| if (ns == null) { |
| // Generic wifi request. Turn off auto-join if necessary. |
| if (mGenericConnectionReqCount == 0) { |
| Log.e(TAG, "No valid network request to release"); |
| return; |
| } |
| if (--mGenericConnectionReqCount == 0) { |
| mWifiConnectivityManager.setTrustedConnectionAllowed(false); |
| } |
| } else { |
| // Unsupported network specifier. |
| if (!(ns instanceof WifiNetworkSpecifier)) { |
| Log.e(TAG, "Unsupported network specifier mentioned. Ignoring"); |
| return; |
| } |
| if (mActiveSpecificNetworkRequest == null && mConnectedSpecificNetworkRequest == null) { |
| Log.e(TAG, "Network release received with no active/connected request." |
| + " Ignoring"); |
| return; |
| } |
| if (Objects.equals(mActiveSpecificNetworkRequest, networkRequest)) { |
| Log.i(TAG, "App released active request, cancelling " |
| + mActiveSpecificNetworkRequest); |
| teardownForActiveRequest(); |
| } else if (Objects.equals(mConnectedSpecificNetworkRequest, networkRequest)) { |
| Log.i(TAG, "App released connected request, cancelling " |
| + mConnectedSpecificNetworkRequest); |
| teardownForConnectedNetwork(); |
| } else { |
| Log.e(TAG, "Network specifier does not match the active/connected request." |
| + " Ignoring"); |
| } |
| } |
| } |
| |
| @Override |
| public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| super.dump(fd, pw, args); |
| pw.println(TAG + ": mGenericConnectionReqCount " + mGenericConnectionReqCount); |
| pw.println(TAG + ": mActiveSpecificNetworkRequest " + mActiveSpecificNetworkRequest); |
| pw.println(TAG + ": mUserApprovedAccessPointMap " + mUserApprovedAccessPointMap); |
| } |
| |
| /** |
| * Check if there is at least one connection request. |
| */ |
| public boolean hasConnectionRequests() { |
| return mGenericConnectionReqCount > 0 || mActiveSpecificNetworkRequest != null |
| || mConnectedSpecificNetworkRequest != null; |
| } |
| |
| /** |
| * Return the uid of the specific network request being processed if connected to the requested |
| * network. |
| * |
| * @param connectedNetwork WifiConfiguration corresponding to the connected network. |
| * @return Pair of uid & package name of the specific request (if any), else <-1, "">. |
| */ |
| public Pair<Integer, String> getSpecificNetworkRequestUidAndPackageName( |
| @NonNull WifiConfiguration connectedNetwork, @NonNull String connectedBssid) { |
| if (mUserSelectedNetwork == null || connectedNetwork == null) { |
| return Pair.create(Process.INVALID_UID, ""); |
| } |
| if (!isUserSelectedNetwork(connectedNetwork, connectedBssid)) { |
| Log.w(TAG, "Connected to unknown network " + connectedNetwork + ":" + connectedBssid |
| + ". Ignoring..."); |
| return Pair.create(Process.INVALID_UID, ""); |
| } |
| if (mConnectedSpecificNetworkRequestSpecifier != null) { |
| return Pair.create(mConnectedSpecificNetworkRequest.getRequestorUid(), |
| mConnectedSpecificNetworkRequest.getRequestorPackageName()); |
| } |
| if (mActiveSpecificNetworkRequestSpecifier != null) { |
| return Pair.create(mActiveSpecificNetworkRequest.getRequestorUid(), |
| mActiveSpecificNetworkRequest.getRequestorPackageName()); |
| } |
| return Pair.create(Process.INVALID_UID, ""); |
| } |
| |
| // Helper method to add the provided network configuration to WifiConfigManager, if it does not |
| // already exist & return the allocated network ID. This ID will be used in the CONNECT_NETWORK |
| // request to ClientModeImpl. |
| // If the network already exists, just return the network ID of the existing network. |
| private int addNetworkToWifiConfigManager(@NonNull WifiConfiguration network) { |
| WifiConfiguration existingSavedNetwork = |
| mWifiConfigManager.getConfiguredNetwork(network.getProfileKey()); |
| if (existingSavedNetwork != null) { |
| if (WifiConfigurationUtil.hasCredentialChanged(existingSavedNetwork, network)) { |
| // TODO (b/142035508): What if the user has a saved network with different |
| // credentials? |
| Log.w(TAG, "Network config already present in config manager, reusing"); |
| } |
| return existingSavedNetwork.networkId; |
| } |
| NetworkUpdateResult networkUpdateResult = |
| mWifiConfigManager.addOrUpdateNetwork( |
| network, mActiveSpecificNetworkRequest.getRequestorUid(), |
| mActiveSpecificNetworkRequest.getRequestorPackageName()); |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Added network to config manager " + networkUpdateResult.getNetworkId()); |
| } |
| return networkUpdateResult.getNetworkId(); |
| } |
| |
| // Helper method to remove the provided network configuration from WifiConfigManager, if it was |
| // added by an app's specifier request. |
| private void disconnectAndRemoveNetworkFromWifiConfigManager( |
| @Nullable WifiConfiguration network) { |
| // Trigger a disconnect first. |
| if (mClientModeManager != null) mClientModeManager.disconnect(); |
| |
| if (network == null) return; |
| WifiConfiguration wcmNetwork = |
| mWifiConfigManager.getConfiguredNetwork(network.getProfileKey()); |
| if (wcmNetwork == null) { |
| Log.e(TAG, "Network not present in config manager"); |
| return; |
| } |
| // Remove the network if it was added previously by an app's specifier request. |
| if (wcmNetwork.ephemeral && wcmNetwork.fromWifiNetworkSpecifier) { |
| boolean success = |
| mWifiConfigManager.removeNetwork( |
| wcmNetwork.networkId, wcmNetwork.creatorUid, wcmNetwork.creatorName); |
| if (!success) { |
| Log.e(TAG, "Failed to remove network from config manager"); |
| } else if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Removed network from config manager " + wcmNetwork.networkId); |
| } |
| } |
| } |
| |
| // Helper method to trigger a connection request & schedule a timeout alarm to track the |
| // connection request. |
| private void connectToNetwork(@NonNull WifiConfiguration network) { |
| // Cancel connection timeout alarm for any previous connection attempts. |
| cancelConnectionTimeout(); |
| |
| // First add the network to WifiConfigManager and then use the obtained networkId |
| // in the CONNECT_NETWORK request. |
| // Note: We don't do any error checks on the networkId because ClientModeImpl will do the |
| // necessary checks when processing CONNECT_NETWORK. |
| int networkId = addNetworkToWifiConfigManager(network); |
| |
| mWifiMetrics.setNominatorForNetwork(networkId, |
| WifiMetricsProto.ConnectionEvent.NOMINATOR_SPECIFIER); |
| if (mClientModeManagerRole == ROLE_CLIENT_PRIMARY) { |
| mWifiMetrics.incrementNetworkRequestApiNumConnectOnPrimaryIface(); |
| } else { |
| mWifiMetrics.incrementNetworkRequestApiNumConnectOnSecondaryIface(); |
| } |
| |
| // Send the connect request to ClientModeImpl. |
| // TODO(b/117601161): Refactor this. |
| ConnectActionListener listener = new ConnectActionListener(); |
| mConnectHelper.connectToNetwork( |
| mClientModeManager, |
| new NetworkUpdateResult(networkId), |
| new ActionListenerWrapper(listener), |
| mActiveSpecificNetworkRequest.getRequestorUid()); |
| |
| // Post an alarm to handle connection timeout. |
| scheduleConnectionTimeout(); |
| } |
| |
| private void handleConnectToNetworkUserSelectionInternal(WifiConfiguration network) { |
| // Copy over the credentials from the app's request and then copy the ssid from user |
| // selection. |
| WifiConfiguration networkToConnect = |
| new WifiConfiguration(mActiveSpecificNetworkRequestSpecifier.wifiConfiguration); |
| networkToConnect.SSID = network.SSID; |
| // Set the WifiConfiguration.BSSID field to prevent roaming. |
| if (network.BSSID != null) { |
| // If pre-approved, use the bssid from the request. |
| networkToConnect.BSSID = network.BSSID; |
| } else { |
| // If not pre-approved, find the best bssid matching the request. |
| networkToConnect.BSSID = |
| findBestBssidFromActiveMatchedScanResultsForNetwork( |
| ScanResultMatchInfo.fromWifiConfiguration(networkToConnect)); |
| } |
| networkToConnect.ephemeral = true; |
| // Mark it user private to avoid conflicting with any saved networks the user might have. |
| // TODO (b/142035508): Use a more generic mechanism to fix this. |
| networkToConnect.shared = false; |
| networkToConnect.fromWifiNetworkSpecifier = true; |
| |
| // TODO(b/188021807): Implement the band request from the specifier on the network to |
| // connect. |
| |
| // Store the user selected network. |
| mUserSelectedNetwork = networkToConnect; |
| |
| // Request a new CMM for the connection processing. |
| if (mVerboseLoggingEnabled) Log.v(TAG, "Requesting new ClientModeManager instance"); |
| mActiveModeWarden.requestLocalOnlyClientModeManager( |
| new ClientModeManagerRequestListener(), |
| new WorkSource(mActiveSpecificNetworkRequest.getRequestorUid(), |
| mActiveSpecificNetworkRequest.getRequestorPackageName()), |
| networkToConnect.SSID, networkToConnect.BSSID); |
| } |
| |
| private void handleConnectToNetworkUserSelection(WifiConfiguration network) { |
| Log.d(TAG, "User initiated connect to network: " + network.SSID); |
| |
| // Cancel the ongoing scans after user selection. |
| cancelPeriodicScans(); |
| mIsPeriodicScanEnabled = false; |
| |
| // Trigger connection attempts. |
| handleConnectToNetworkUserSelectionInternal(network); |
| |
| // Add the network to the approved access point map for the app. |
| addNetworkToUserApprovedAccessPointMap(mUserSelectedNetwork); |
| } |
| |
| private void handleRejectUserSelection() { |
| Log.w(TAG, "User dismissed notification, cancelling " + mActiveSpecificNetworkRequest); |
| teardownForActiveRequest(); |
| mWifiMetrics.incrementNetworkRequestApiNumUserReject(); |
| } |
| |
| private boolean isUserSelectedNetwork(WifiConfiguration config, String bssid) { |
| if (!TextUtils.equals(mUserSelectedNetwork.SSID, config.SSID)) { |
| return false; |
| } |
| if (!Objects.equals( |
| mUserSelectedNetwork.allowedKeyManagement, config.allowedKeyManagement)) { |
| return false; |
| } |
| if (!TextUtils.equals(mUserSelectedNetwork.BSSID, bssid)) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Invoked by {@link ClientModeImpl} on end of connection attempt to a network. |
| */ |
| public void handleConnectionAttemptEnded( |
| int failureCode, @NonNull WifiConfiguration network, @NonNull String bssid) { |
| if (failureCode == WifiMetrics.ConnectionEvent.FAILURE_NONE) { |
| handleNetworkConnectionSuccess(network, bssid); |
| } else { |
| handleNetworkConnectionFailure(network, bssid); |
| } |
| } |
| |
| /** |
| * Invoked by {@link ClientModeImpl} on successful connection to a network. |
| */ |
| private void handleNetworkConnectionSuccess(@NonNull WifiConfiguration connectedNetwork, |
| @NonNull String connectedBssid) { |
| if (mUserSelectedNetwork == null || connectedNetwork == null |
| || !mPendingConnectionSuccess) { |
| return; |
| } |
| if (!isUserSelectedNetwork(connectedNetwork, connectedBssid)) { |
| Log.w(TAG, "Connected to unknown network " + connectedNetwork + ":" + connectedBssid |
| + ". Ignoring..."); |
| return; |
| } |
| Log.d(TAG, "Connected to network " + mUserSelectedNetwork); |
| if (mRegisteredCallbacks != null) { |
| int itemCount = mRegisteredCallbacks.beginBroadcast(); |
| for (int i = 0; i < itemCount; i++) { |
| try { |
| mRegisteredCallbacks.getBroadcastItem(i).onUserSelectionConnectSuccess( |
| mUserSelectedNetwork); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Unable to invoke network request connect failure callback ", e); |
| } |
| } |
| mRegisteredCallbacks.finishBroadcast(); |
| } |
| // transition the request from "active" to "connected". |
| setupForConnectedRequest(); |
| } |
| |
| /** |
| * Invoked by {@link ClientModeImpl} on failure to connect to a network. |
| */ |
| private void handleNetworkConnectionFailure(@NonNull WifiConfiguration failedNetwork, |
| @NonNull String failedBssid) { |
| if (mUserSelectedNetwork == null || failedNetwork == null || !mPendingConnectionSuccess) { |
| return; |
| } |
| if (!isUserSelectedNetwork(failedNetwork, failedBssid)) { |
| Log.w(TAG, "Connection failed to unknown network " + failedNetwork + ":" + failedBssid |
| + ". Ignoring..."); |
| return; |
| } |
| Log.w(TAG, "Failed to connect to network " + mUserSelectedNetwork); |
| if (mUserSelectedNetworkConnectRetryCount++ < USER_SELECTED_NETWORK_CONNECT_RETRY_MAX) { |
| Log.i(TAG, "Retrying connection attempt, attempt# " |
| + mUserSelectedNetworkConnectRetryCount); |
| connectToNetwork(mUserSelectedNetwork); |
| return; |
| } |
| Log.e(TAG, "Connection failures, cancelling " + mUserSelectedNetwork); |
| if (mRegisteredCallbacks != null) { |
| int itemCount = mRegisteredCallbacks.beginBroadcast(); |
| for (int i = 0; i < itemCount; i++) { |
| try { |
| mRegisteredCallbacks.getBroadcastItem(i).onUserSelectionConnectFailure( |
| mUserSelectedNetwork); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Unable to invoke network request connect failure callback ", e); |
| } |
| } |
| mRegisteredCallbacks.finishBroadcast(); |
| } |
| teardownForActiveRequest(); |
| } |
| |
| /** |
| * Invoked by {@link ClientModeImpl} to indicate screen state changes. |
| */ |
| private void handleScreenStateChanged(boolean screenOn) { |
| // If there is no active request or if the user has already selected a network, |
| // ignore screen state changes. |
| if (mActiveSpecificNetworkRequest == null || !mIsPeriodicScanEnabled) return; |
| |
| // Pause periodic scans when the screen is off & resume when the screen is on. |
| if (screenOn) { |
| if (mVerboseLoggingEnabled) Log.v(TAG, "Resuming scans on screen on"); |
| mIsPeriodicScanPaused = false; |
| startScan(); |
| } else { |
| if (mVerboseLoggingEnabled) Log.v(TAG, "Pausing scans on screen off"); |
| cancelPeriodicScans(); |
| mIsPeriodicScanPaused = true; |
| } |
| } |
| |
| // Common helper method for start/end of active request processing. |
| private void cleanupActiveRequest() { |
| // Send the abort to the UI for the current active request. |
| if (mRegisteredCallbacks != null) { |
| int itemCount = mRegisteredCallbacks.beginBroadcast(); |
| for (int i = 0; i < itemCount; i++) { |
| try { |
| mRegisteredCallbacks.getBroadcastItem(i).onAbort(); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Unable to invoke network request abort callback ", e); |
| } |
| } |
| mRegisteredCallbacks.finishBroadcast(); |
| } |
| // Force-release the network request to let the app know early that the attempt failed. |
| if (mActiveSpecificNetworkRequest != null) { |
| releaseRequestAsUnfulfillableByAnyFactory(mActiveSpecificNetworkRequest); |
| } |
| // Reset the active network request. |
| mActiveSpecificNetworkRequest = null; |
| mActiveSpecificNetworkRequestSpecifier = null; |
| mUserSelectedNetwork = null; |
| mUserSelectedNetworkConnectRetryCount = 0; |
| mIsPeriodicScanEnabled = false; |
| mIsPeriodicScanPaused = false; |
| mActiveMatchedScanResults = null; |
| mPendingConnectionSuccess = false; |
| // Cancel periodic scan, connection timeout alarm. |
| cancelPeriodicScans(); |
| cancelConnectionTimeout(); |
| // Remove any callbacks registered for the request. |
| if (mRegisteredCallbacks != null) mRegisteredCallbacks.kill(); |
| mRegisteredCallbacks = null; |
| } |
| |
| // Invoked at the start of new active request processing. |
| private void setupForActiveRequest() { |
| if (mActiveSpecificNetworkRequest != null) { |
| cleanupActiveRequest(); |
| } |
| } |
| |
| private void removeClientModeManagerIfNecessary() { |
| if (mClientModeManager != null) { |
| if (mClientModeManagerRole == ROLE_CLIENT_PRIMARY) { |
| mWifiConnectivityManager.setSpecificNetworkRequestInProgress(false); |
| } |
| if (mContext.getResources().getBoolean(R.bool.config_wifiUseHalApiToDisableFwRoaming)) { |
| mClientModeManager.enableRoaming(true); // Re-enable roaming. |
| } |
| mActiveModeWarden.removeClientModeManager(mClientModeManager); |
| // For every connection attempt, get the appropriate client mode impl to use. |
| mClientModeManager = null; |
| mClientModeManagerRole = null; |
| } |
| } |
| |
| // Invoked at the termination of current active request processing. |
| private void teardownForActiveRequest() { |
| if (mPendingConnectionSuccess) { |
| Log.i(TAG, "Disconnecting from network on reset"); |
| disconnectAndRemoveNetworkFromWifiConfigManager(mUserSelectedNetwork); |
| } |
| cleanupActiveRequest(); |
| // ensure there is no connected request in progress. |
| if (mConnectedSpecificNetworkRequest == null) { |
| removeClientModeManagerIfNecessary(); |
| } |
| } |
| |
| // Invoked at the start of new connected request processing. |
| private void setupForConnectedRequest() { |
| mConnectedSpecificNetworkRequest = mActiveSpecificNetworkRequest; |
| mConnectedSpecificNetworkRequestSpecifier = mActiveSpecificNetworkRequestSpecifier; |
| mActiveSpecificNetworkRequest = null; |
| mActiveSpecificNetworkRequestSpecifier = null; |
| mActiveMatchedScanResults = null; |
| mPendingConnectionSuccess = false; |
| // Cancel connection timeout alarm. |
| cancelConnectionTimeout(); |
| |
| mConnectionStartTimeMillis = mClock.getElapsedSinceBootMillis(); |
| if (mClientModeManagerRole == ROLE_CLIENT_PRIMARY) { |
| mWifiMetrics.incrementNetworkRequestApiNumConnectSuccessOnPrimaryIface(); |
| } else { |
| mWifiMetrics.incrementNetworkRequestApiNumConnectSuccessOnSecondaryIface(); |
| // secondary STA being used, register CMI listener for concurrent connection metrics |
| // collection. |
| mCmiListener = new CmiListener(); |
| mClientModeImplMonitor.registerListener(mCmiListener); |
| } |
| // Disable roaming. |
| if (mContext.getResources().getBoolean(R.bool.config_wifiUseHalApiToDisableFwRoaming)) { |
| // Note: This is an old HAL API, but since it wasn't being exercised before, we are |
| // being extra cautious and only using it on devices running >= S. |
| if (!mClientModeManager.enableRoaming(false)) { |
| Log.w(TAG, "Failed to disable roaming"); |
| } |
| } |
| } |
| |
| // Invoked at the termination of current connected request processing. |
| private void teardownForConnectedNetwork() { |
| Log.i(TAG, "Disconnecting from network on reset"); |
| disconnectAndRemoveNetworkFromWifiConfigManager(mUserSelectedNetwork); |
| mConnectedSpecificNetworkRequest = null; |
| mConnectedSpecificNetworkRequestSpecifier = null; |
| |
| if (mConnectionStartTimeMillis != -1) { |
| int connectionDurationSec = toIntExact(TimeUnit.MILLISECONDS.toSeconds( |
| mClock.getElapsedSinceBootMillis() - mConnectionStartTimeMillis)); |
| if (mClientModeManagerRole == ROLE_CLIENT_PRIMARY) { |
| mWifiMetrics.incrementNetworkRequestApiConnectionDurationSecOnPrimaryIfaceHistogram( |
| connectionDurationSec); |
| |
| } else { |
| mWifiMetrics |
| .incrementNetworkRequestApiConnectionDurationSecOnSecondaryIfaceHistogram( |
| connectionDurationSec); |
| } |
| mConnectionStartTimeMillis = -1L; |
| } |
| if (mCmiListener != null) { |
| mCmiListener.checkForConcurrencyEndAndIncrementMetrics(); |
| mClientModeImplMonitor.unregisterListener(mCmiListener); |
| mCmiListener = null; |
| } |
| // ensure there is no active request in progress. |
| if (mActiveSpecificNetworkRequest == null) { |
| removeClientModeManagerIfNecessary(); |
| } |
| } |
| |
| /** |
| * Check if the request comes from foreground app/service. |
| */ |
| private boolean isRequestFromForegroundAppOrService(@NonNull String requestorPackageName) { |
| try { |
| return mActivityManager.getPackageImportance(requestorPackageName) |
| <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND_SERVICE; |
| } catch (SecurityException e) { |
| Log.e(TAG, "Failed to check the app state", e); |
| return false; |
| } |
| } |
| |
| /** |
| * Check if the request comes from foreground app. |
| */ |
| private boolean isRequestFromForegroundApp(@NonNull String requestorPackageName) { |
| try { |
| return mActivityManager.getPackageImportance(requestorPackageName) |
| <= ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND; |
| } catch (SecurityException e) { |
| Log.e(TAG, "Failed to check the app state", e); |
| return false; |
| } |
| } |
| |
| /** |
| * Helper method to populate WifiScanner handle. This is done lazily because |
| * WifiScanningService is started after WifiService. |
| */ |
| private void retrieveWifiScanner() { |
| if (mWifiScanner != null) return; |
| mWifiScanner = mWifiInjector.getWifiScanner(); |
| checkNotNull(mWifiScanner); |
| } |
| |
| private void handleClientModeManagerRetrieval() { |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "ClientModeManager retrieved: " + mClientModeManager); |
| } |
| if (mUserSelectedNetwork == null) { |
| Log.e(TAG, "No user selected network to connect to. Ignoring ClientModeManager" |
| + "retrieval.."); |
| return; |
| } |
| |
| // If using primary STA, disable Auto-join so that NetworkFactory can take control of the |
| // network connection. |
| if (mClientModeManagerRole == ROLE_CLIENT_PRIMARY) { |
| mWifiConnectivityManager.setSpecificNetworkRequestInProgress(true); |
| } |
| |
| // Disconnect from the current network before issuing a new connect request. |
| disconnectAndRemoveNetworkFromWifiConfigManager(mUserSelectedNetwork); |
| |
| // Trigger connection to the network. |
| connectToNetwork(mUserSelectedNetwork); |
| // Triggered connection to network, now wait for the connection status. |
| mPendingConnectionSuccess = true; |
| } |
| |
| private void handleClientModeManagerRemovalOrFailure() { |
| if (mActiveSpecificNetworkRequest != null) { |
| Log.w(TAG, "ClientModeManager retrieval failed or removed, cancelling " |
| + mActiveSpecificNetworkRequest); |
| teardownForActiveRequest(); |
| } |
| if (mConnectedSpecificNetworkRequest != null) { |
| Log.w(TAG, "ClientModeManager retrieval failed or removed, cancelling " |
| + mConnectedSpecificNetworkRequest); |
| teardownForConnectedNetwork(); |
| } |
| } |
| |
| private void startPeriodicScans() { |
| if (mActiveSpecificNetworkRequestSpecifier == null) { |
| Log.e(TAG, "Periodic scan triggered when there is no active network request. " |
| + "Ignoring..."); |
| return; |
| } |
| WifiNetworkSpecifier wns = mActiveSpecificNetworkRequestSpecifier; |
| WifiConfiguration wifiConfiguration = wns.wifiConfiguration; |
| if (wifiConfiguration.hiddenSSID) { |
| // Can't search for SSID pattern in hidden networks. |
| mScanSettings.hiddenNetworks.clear(); |
| mScanSettings.hiddenNetworks.add(new WifiScanner.ScanSettings.HiddenNetwork( |
| addEnclosingQuotes(wns.ssidPatternMatcher.getPath()))); |
| } |
| mIsPeriodicScanEnabled = true; |
| startScan(); |
| } |
| |
| private void cancelPeriodicScans() { |
| if (mPeriodicScanTimerSet) { |
| mAlarmManager.cancel(mPeriodicScanTimerListener); |
| mPeriodicScanTimerSet = false; |
| } |
| // Clear the hidden networks field after each request. |
| mScanSettings.hiddenNetworks.clear(); |
| } |
| |
| private void scheduleNextPeriodicScan() { |
| if (mIsPeriodicScanPaused) { |
| Log.e(TAG, "Scan triggered when periodic scanning paused. Ignoring..."); |
| return; |
| } |
| mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, |
| mClock.getElapsedSinceBootMillis() + PERIODIC_SCAN_INTERVAL_MS, |
| TAG, mPeriodicScanTimerListener, mHandler); |
| mPeriodicScanTimerSet = true; |
| } |
| |
| private void startScan() { |
| if (mActiveSpecificNetworkRequestSpecifier == null) { |
| Log.e(TAG, "Scan triggered when there is no active network request. Ignoring..."); |
| return; |
| } |
| if (!mIsPeriodicScanEnabled) { |
| Log.e(TAG, "Scan triggered after user selected network. Ignoring..."); |
| return; |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Starting the next scan for " + mActiveSpecificNetworkRequestSpecifier); |
| } |
| // Create a worksource using the caller's UID. |
| WorkSource workSource = new WorkSource(mActiveSpecificNetworkRequest.getRequestorUid()); |
| mWifiScanner.startScan( |
| mScanSettings, new HandlerExecutor(mHandler), mScanListener, workSource); |
| } |
| |
| private boolean doesScanResultMatchWifiNetworkSpecifier( |
| WifiNetworkSpecifier wns, ScanResult scanResult) { |
| if (!wns.ssidPatternMatcher.match(scanResult.SSID)) { |
| return false; |
| } |
| MacAddress bssid = MacAddress.fromString(scanResult.BSSID); |
| MacAddress matchBaseAddress = wns.bssidPatternMatcher.first; |
| MacAddress matchMask = wns.bssidPatternMatcher.second; |
| if (!bssid.matches(matchBaseAddress, matchMask)) { |
| return false; |
| } |
| ScanResultMatchInfo fromScanResult = ScanResultMatchInfo.fromScanResult(scanResult); |
| ScanResultMatchInfo fromWifiConfiguration = |
| ScanResultMatchInfo.fromWifiConfiguration(wns.wifiConfiguration); |
| return fromScanResult.networkTypeEquals(fromWifiConfiguration); |
| } |
| |
| // Loops through the scan results and finds scan results matching the active network |
| // request. |
| private List<ScanResult> getNetworksMatchingActiveNetworkRequest( |
| ScanResult[] scanResults) { |
| if (mActiveSpecificNetworkRequestSpecifier == null) { |
| Log.e(TAG, "Scan results received with no active network request. Ignoring..."); |
| return new ArrayList<>(); |
| } |
| List<ScanResult> matchedScanResults = new ArrayList<>(); |
| WifiNetworkSpecifier wns = mActiveSpecificNetworkRequestSpecifier; |
| |
| for (ScanResult scanResult : scanResults) { |
| if (doesScanResultMatchWifiNetworkSpecifier(wns, scanResult)) { |
| matchedScanResults.add(scanResult); |
| } |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "List of scan results matching the active request " |
| + matchedScanResults); |
| } |
| return matchedScanResults; |
| } |
| |
| private void sendNetworkRequestMatchCallbacksForActiveRequest( |
| @NonNull Collection<ScanResult> matchedScanResults) { |
| if (matchedScanResults.isEmpty()) return; |
| if (mRegisteredCallbacks == null |
| || mRegisteredCallbacks.getRegisteredCallbackCount() == 0) { |
| Log.e(TAG, "No callback registered for sending network request matches. " |
| + "Ignoring..."); |
| return; |
| } |
| int itemCount = mRegisteredCallbacks.beginBroadcast(); |
| for (int i = 0; i < itemCount; i++) { |
| try { |
| mRegisteredCallbacks.getBroadcastItem(i).onMatch( |
| new ArrayList<>(matchedScanResults)); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Unable to invoke network request match callback ", e); |
| } |
| } |
| mRegisteredCallbacks.finishBroadcast(); |
| } |
| |
| private void cancelConnectionTimeout() { |
| if (mConnectionTimeoutSet) { |
| mAlarmManager.cancel(mConnectionTimeoutAlarmListener); |
| mConnectionTimeoutSet = false; |
| } |
| } |
| |
| private void scheduleConnectionTimeout() { |
| mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, |
| mClock.getElapsedSinceBootMillis() + NETWORK_CONNECTION_TIMEOUT_MS, |
| TAG, mConnectionTimeoutAlarmListener, mHandler); |
| mConnectionTimeoutSet = true; |
| } |
| |
| private @NonNull CharSequence getAppName(@NonNull String packageName, int uid) { |
| ApplicationInfo applicationInfo = null; |
| try { |
| applicationInfo = mContext.getPackageManager().getApplicationInfoAsUser( |
| packageName, 0, UserHandle.getUserHandleForUid(uid)); |
| } catch (PackageManager.NameNotFoundException e) { |
| Log.e(TAG, "Failed to find app name for " + packageName); |
| return ""; |
| } |
| CharSequence appName = mContext.getPackageManager().getApplicationLabel(applicationInfo); |
| return (appName != null) ? appName : ""; |
| } |
| |
| private void startUi() { |
| Intent intent = new Intent(); |
| intent.setAction(UI_START_INTENT_ACTION); |
| intent.addCategory(UI_START_INTENT_CATEGORY); |
| intent.setFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT | Intent.FLAG_ACTIVITY_NEW_TASK); |
| intent.putExtra(UI_START_INTENT_EXTRA_APP_NAME, |
| getAppName(mActiveSpecificNetworkRequest.getRequestorPackageName(), |
| mActiveSpecificNetworkRequest.getRequestorUid())); |
| intent.putExtra(UI_START_INTENT_EXTRA_REQUEST_IS_FOR_SINGLE_NETWORK, |
| isActiveRequestForSingleNetwork()); |
| mContext.startActivityAsUser(intent, UserHandle.getUserHandleForUid( |
| mActiveSpecificNetworkRequest.getRequestorUid())); |
| } |
| |
| // Helper method to determine if the specifier does not contain any patterns and matches |
| // a single access point. |
| private boolean isActiveRequestForSingleAccessPoint() { |
| if (mActiveSpecificNetworkRequestSpecifier == null) return false; |
| |
| if (mActiveSpecificNetworkRequestSpecifier.ssidPatternMatcher.getType() |
| != PatternMatcher.PATTERN_LITERAL) { |
| return false; |
| } |
| if (!Objects.equals( |
| mActiveSpecificNetworkRequestSpecifier.bssidPatternMatcher.second, |
| MacAddress.BROADCAST_ADDRESS)) { |
| return false; |
| } |
| return true; |
| } |
| |
| // Helper method to determine if the specifier does not contain any patterns and matches |
| // a single network. |
| private boolean isActiveRequestForSingleNetwork() { |
| if (mActiveSpecificNetworkRequestSpecifier == null) return false; |
| |
| if (mActiveSpecificNetworkRequestSpecifier.ssidPatternMatcher.getType() |
| == PatternMatcher.PATTERN_LITERAL) { |
| return true; |
| } |
| if (Objects.equals( |
| mActiveSpecificNetworkRequestSpecifier.bssidPatternMatcher.second, |
| MacAddress.BROADCAST_ADDRESS)) { |
| return true; |
| } |
| return false; |
| } |
| |
| // Will return the best bssid to use for the current request's connection. |
| // |
| // Note: This will never return null, unless there is some internal error. |
| // For ex: |
| // i) The latest scan results were empty. |
| // ii) The latest scan result did not contain any BSSID for the SSID user chose. |
| private @Nullable String findBestBssidFromActiveMatchedScanResultsForNetwork( |
| @NonNull ScanResultMatchInfo scanResultMatchInfo) { |
| if (mActiveSpecificNetworkRequestSpecifier == null |
| || mActiveMatchedScanResults == null) return null; |
| ScanResult selectedScanResult = mActiveMatchedScanResults |
| .values() |
| .stream() |
| .filter(scanResult -> Objects.equals( |
| ScanResultMatchInfo.fromScanResult(scanResult), |
| scanResultMatchInfo)) |
| .max(Comparator.comparing(scanResult -> scanResult.level)) |
| .orElse(null); |
| if (selectedScanResult == null) { // Should never happen. |
| Log.wtf(TAG, "Expected to find at least one matching scan result"); |
| return null; |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Best bssid selected for the request " + selectedScanResult); |
| } |
| return selectedScanResult.BSSID; |
| } |
| |
| private boolean isAccessPointApprovedInInternalApprovalList( |
| @NonNull String ssid, @NonNull MacAddress bssid, @SecurityType int networkType, |
| @NonNull String requestorPackageName) { |
| Set<AccessPoint> approvedAccessPoints = |
| mUserApprovedAccessPointMap.get(requestorPackageName); |
| if (approvedAccessPoints == null) return false; |
| AccessPoint accessPoint = |
| new AccessPoint(ssid, bssid, networkType); |
| if (!approvedAccessPoints.contains(accessPoint)) return false; |
| // keep the most recently used AP in the end |
| approvedAccessPoints.remove(accessPoint); |
| approvedAccessPoints.add(accessPoint); |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Found " + bssid |
| + " in internal user approved access point for " + requestorPackageName); |
| } |
| return true; |
| } |
| |
| private boolean isAccessPointApprovedInCompanionDeviceManager( |
| @NonNull MacAddress bssid, |
| @NonNull UserHandle requestorUserHandle, |
| @NonNull String requestorPackageName) { |
| if (mCompanionDeviceManager == null) { |
| mCompanionDeviceManager = mContext.getSystemService(CompanionDeviceManager.class); |
| } |
| boolean approved = mCompanionDeviceManager.isDeviceAssociatedForWifiConnection( |
| requestorPackageName, bssid, requestorUserHandle); |
| if (!approved) return false; |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Found " + bssid |
| + " in CompanionDeviceManager approved access point for " |
| + requestorPackageName); |
| } |
| return true; |
| } |
| |
| private boolean isAccessPointApprovedForActiveRequest(@NonNull String ssid, |
| @NonNull MacAddress bssid, @SecurityType int networkType) { |
| String requestorPackageName = mActiveSpecificNetworkRequest.getRequestorPackageName(); |
| UserHandle requestorUserHandle = |
| UserHandle.getUserHandleForUid(mActiveSpecificNetworkRequest.getRequestorUid()); |
| // Check if access point is approved via CompanionDeviceManager first. |
| if (isAccessPointApprovedInCompanionDeviceManager( |
| bssid, requestorUserHandle, requestorPackageName)) { |
| return true; |
| } |
| // Check if access point is approved in internal approval list next. |
| if (isAccessPointApprovedInInternalApprovalList( |
| ssid, bssid, networkType, requestorPackageName)) { |
| return true; |
| } |
| // Shell approved app |
| if (TextUtils.equals(mApprovedApp, requestorPackageName)) { |
| return true; |
| } |
| // no bypass approvals, show UI. |
| return false; |
| } |
| |
| |
| // Helper method to store the all the BSSIDs matching the network from the matched scan results |
| private void addNetworkToUserApprovedAccessPointMap(@NonNull WifiConfiguration network) { |
| if (mActiveSpecificNetworkRequestSpecifier == null |
| || mActiveMatchedScanResults == null) return; |
| // Note: This hopefully is a list of size 1, because we want to store a 1:1 mapping |
| // from user selection and the AP that was approved. But, since we get a WifiConfiguration |
| // object representing an entire network from UI, we need to ensure that all the visible |
| // BSSIDs matching the original request and the selected network are stored. |
| Set<AccessPoint> newUserApprovedAccessPoints = new HashSet<>(); |
| |
| ScanResultMatchInfo fromWifiConfiguration = |
| ScanResultMatchInfo.fromWifiConfiguration(network); |
| for (ScanResult scanResult : mActiveMatchedScanResults.values()) { |
| ScanResultMatchInfo fromScanResult = ScanResultMatchInfo.fromScanResult(scanResult); |
| SecurityParams params = fromScanResult.matchForNetworkSelection(fromWifiConfiguration); |
| if (null != params) { |
| AccessPoint approvedAccessPoint = |
| new AccessPoint(scanResult.SSID, MacAddress.fromString(scanResult.BSSID), |
| params.getSecurityType()); |
| newUserApprovedAccessPoints.add(approvedAccessPoint); |
| } |
| } |
| if (newUserApprovedAccessPoints.isEmpty()) return; |
| |
| String requestorPackageName = mActiveSpecificNetworkRequest.getRequestorPackageName(); |
| LinkedHashSet<AccessPoint> approvedAccessPoints = |
| mUserApprovedAccessPointMap.get(requestorPackageName); |
| if (approvedAccessPoints == null) { |
| approvedAccessPoints = new LinkedHashSet<>(); |
| mUserApprovedAccessPointMap.put(requestorPackageName, approvedAccessPoints); |
| // Note the new app in metrics. |
| mWifiMetrics.incrementNetworkRequestApiNumApps(); |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "Adding " + newUserApprovedAccessPoints |
| + " to user approved access point for " + requestorPackageName); |
| } |
| // keep the most recently added APs in the end |
| approvedAccessPoints.removeAll(newUserApprovedAccessPoints); |
| approvedAccessPoints.addAll(newUserApprovedAccessPoints); |
| cleanUpLRUAccessPoints(approvedAccessPoints); |
| saveToStore(); |
| } |
| |
| /** |
| * 1) If the request is for a single bssid, check if the matching ScanResult was pre-approved |
| * by the user. |
| * 2) If yes to (b), trigger a connect immediately and returns true. Else, returns false. |
| * |
| * @return true if a pre-approved network was found for connection, false otherwise. |
| */ |
| private boolean triggerConnectIfUserApprovedMatchFound() { |
| if (mActiveSpecificNetworkRequestSpecifier == null) return false; |
| if (!isActiveRequestForSingleAccessPoint()) return false; |
| String ssid = mActiveSpecificNetworkRequestSpecifier.ssidPatternMatcher.getPath(); |
| MacAddress bssid = mActiveSpecificNetworkRequestSpecifier.bssidPatternMatcher.first; |
| SecurityParams params = |
| ScanResultMatchInfo.fromWifiConfiguration( |
| mActiveSpecificNetworkRequestSpecifier.wifiConfiguration) |
| .getFirstAvailableSecurityParams(); |
| if (null == params) return false; |
| int networkType = params.getSecurityType(); |
| if (!isAccessPointApprovedForActiveRequest(ssid, bssid, networkType) |
| || mWifiConfigManager.isNetworkTemporarilyDisabledByUser( |
| ScanResultUtil.createQuotedSSID(ssid))) { |
| if (mVerboseLoggingEnabled) { |
| Log.v(TAG, "No approved access point found"); |
| } |
| return false; |
| } |
| Log.v(TAG, "Approved access point found in matching scan results. " |
| + "Triggering connect " + ssid + "/" + bssid); |
| WifiConfiguration config = mActiveSpecificNetworkRequestSpecifier.wifiConfiguration; |
| config.SSID = "\"" + ssid + "\""; |
| config.BSSID = bssid.toString(); |
| handleConnectToNetworkUserSelectionInternal(config); |
| mWifiMetrics.incrementNetworkRequestApiNumUserApprovalBypass(); |
| return true; |
| } |
| |
| /** |
| * Handle scan results |
| * |
| * @param scanResults Array of {@link ScanResult} to be processed. |
| */ |
| private void handleScanResults(ScanResult[] scanResults) { |
| List<ScanResult> matchedScanResults = |
| getNetworksMatchingActiveNetworkRequest(scanResults); |
| if ((mActiveMatchedScanResults == null || mActiveMatchedScanResults.isEmpty()) |
| && !matchedScanResults.isEmpty()) { |
| // only note the first match size in metrics (chances of this changing in further |
| // scans is pretty low) |
| mWifiMetrics.incrementNetworkRequestApiMatchSizeHistogram( |
| matchedScanResults.size()); |
| } |
| // First set of scan results for this request. |
| if (mActiveMatchedScanResults == null) mActiveMatchedScanResults = new HashMap<>(); |
| // Coalesce the new set of scan results with previous scan results received for request. |
| mActiveMatchedScanResults.putAll(matchedScanResults |
| .stream() |
| .collect(Collectors.toMap( |
| scanResult -> scanResult.BSSID, scanResult -> scanResult, (a, b) -> a))); |
| // Weed out any stale cached scan results. |
| long currentTimeInMillis = mClock.getElapsedSinceBootMillis(); |
| mActiveMatchedScanResults.entrySet().removeIf( |
| e -> ((currentTimeInMillis - (e.getValue().timestamp / 1000)) |
| >= CACHED_SCAN_RESULTS_MAX_AGE_IN_MILLIS)); |
| } |
| |
| /** |
| * Retrieve the latest cached scan results from wifi scanner and filter out any |
| * {@link ScanResult} older than {@link #CACHED_SCAN_RESULTS_MAX_AGE_IN_MILLIS}. |
| */ |
| private @NonNull ScanResult[] getFilteredCachedScanResults() { |
| List<ScanResult> cachedScanResults = mWifiScanner.getSingleScanResults(); |
| if (cachedScanResults == null || cachedScanResults.isEmpty()) return new ScanResult[0]; |
| long currentTimeInMillis = mClock.getElapsedSinceBootMillis(); |
| return cachedScanResults.stream() |
| .filter(scanResult |
| -> ((currentTimeInMillis - (scanResult.timestamp / 1000)) |
| < CACHED_SCAN_RESULTS_MAX_AGE_IN_MILLIS)) |
| .toArray(ScanResult[]::new); |
| } |
| |
| /** |
| * Clean up least recently used Access Points if specified app reach the limit. |
| */ |
| private static void cleanUpLRUAccessPoints(Set<AccessPoint> approvedAccessPoints) { |
| if (approvedAccessPoints.size() <= NUM_OF_ACCESS_POINT_LIMIT_PER_APP) { |
| return; |
| } |
| Iterator iter = approvedAccessPoints.iterator(); |
| while (iter.hasNext() && approvedAccessPoints.size() > NUM_OF_ACCESS_POINT_LIMIT_PER_APP) { |
| iter.next(); |
| iter.remove(); |
| } |
| } |
| |
| /** |
| * Sets all access points approved for the specified app. |
| * Used by shell commands. |
| */ |
| public void setUserApprovedApp(@NonNull String packageName, boolean approved) { |
| if (approved) { |
| mApprovedApp = packageName; |
| } else if (TextUtils.equals(packageName, mApprovedApp)) { |
| mApprovedApp = null; |
| } |
| } |
| |
| /** |
| * Whether all access points are approved for the specified app. |
| * Used by shell commands. |
| */ |
| public boolean hasUserApprovedApp(@NonNull String packageName) { |
| return TextUtils.equals(packageName, mApprovedApp); |
| } |
| |
| /** |
| * Remove all user approved access points for the specified app. |
| */ |
| public void removeUserApprovedAccessPointsForApp(@NonNull String packageName) { |
| if (mUserApprovedAccessPointMap.remove(packageName) != null) { |
| Log.i(TAG, "Removing all approved access points for " + packageName); |
| } |
| saveToStore(); |
| } |
| |
| /** |
| * Clear all internal state (for network settings reset). |
| */ |
| public void clear() { |
| mUserApprovedAccessPointMap.clear(); |
| mApprovedApp = null; |
| Log.i(TAG, "Cleared all internal state"); |
| saveToStore(); |
| } |
| } |
