| /* |
| * Copyright (C) 2017 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 android.net.wifi.WifiManager.WIFI_FEATURE_OWE; |
| |
| import android.annotation.NonNull; |
| import android.app.AlarmManager; |
| import android.net.wifi.IApInterface; |
| import android.net.wifi.IApInterfaceEventCallback; |
| import android.net.wifi.IClientInterface; |
| import android.net.wifi.IPnoScanEvent; |
| import android.net.wifi.IScanEvent; |
| import android.net.wifi.ISendMgmtFrameEvent; |
| import android.net.wifi.IWifiScannerImpl; |
| import android.net.wifi.IWificond; |
| import android.net.wifi.ScanResult; |
| import android.net.wifi.WifiScanner; |
| import android.net.wifi.WifiSsid; |
| import android.os.Binder; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Looper; |
| import android.os.RemoteException; |
| import android.util.Log; |
| |
| import com.android.server.wifi.WifiNative.SendMgmtFrameCallback; |
| import com.android.server.wifi.WifiNative.SoftApListener; |
| import com.android.server.wifi.hotspot2.NetworkDetail; |
| import com.android.server.wifi.util.InformationElementUtil; |
| import com.android.server.wifi.util.NativeUtil; |
| import com.android.server.wifi.util.ScanResultUtil; |
| import com.android.server.wifi.wificond.ChannelSettings; |
| import com.android.server.wifi.wificond.HiddenNetwork; |
| import com.android.server.wifi.wificond.NativeScanResult; |
| import com.android.server.wifi.wificond.PnoNetwork; |
| import com.android.server.wifi.wificond.PnoSettings; |
| import com.android.server.wifi.wificond.RadioChainInfo; |
| import com.android.server.wifi.wificond.SingleScanSettings; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| |
| /** |
| * This class provides methods for WifiNative to send control commands to wificond. |
| * NOTE: This class should only be used from WifiNative. |
| */ |
| public class WificondControl implements IBinder.DeathRecipient { |
| private boolean mVerboseLoggingEnabled = false; |
| |
| /** |
| * The {@link #sendMgmtFrame(String, byte[], SendMgmtFrameCallback, int) sendMgmtFrame()} |
| * timeout, in milliseconds, after which |
| * {@link SendMgmtFrameCallback#onFailure(int)} will be called with reason |
| * {@link WifiNative#SEND_MGMT_FRAME_ERROR_TIMEOUT}. |
| */ |
| public static final int SEND_MGMT_FRAME_TIMEOUT_MS = 1000; |
| |
| private static final String TAG = "WificondControl"; |
| |
| private static final String TIMEOUT_ALARM_TAG = TAG + " Send Management Frame Timeout"; |
| |
| /* Get scan results for a single scan */ |
| public static final int SCAN_TYPE_SINGLE_SCAN = 0; |
| |
| /* Get scan results for Pno Scan */ |
| public static final int SCAN_TYPE_PNO_SCAN = 1; |
| |
| private WifiInjector mWifiInjector; |
| private WifiMonitor mWifiMonitor; |
| private final CarrierNetworkConfig mCarrierNetworkConfig; |
| private AlarmManager mAlarmManager; |
| private Handler mEventHandler; |
| private Clock mClock; |
| private WifiNative mWifiNative = null; |
| |
| // Cached wificond binder handlers. |
| private IWificond mWificond; |
| private HashMap<String, IClientInterface> mClientInterfaces = new HashMap<>(); |
| private HashMap<String, IApInterface> mApInterfaces = new HashMap<>(); |
| private HashMap<String, IWifiScannerImpl> mWificondScanners = new HashMap<>(); |
| private HashMap<String, IScanEvent> mScanEventHandlers = new HashMap<>(); |
| private HashMap<String, IPnoScanEvent> mPnoScanEventHandlers = new HashMap<>(); |
| private HashMap<String, IApInterfaceEventCallback> mApInterfaceListeners = new HashMap<>(); |
| private WifiNative.WificondDeathEventHandler mDeathEventHandler; |
| /** |
| * Ensures that no more than one sendMgmtFrame operation runs concurrently. |
| */ |
| private AtomicBoolean mSendMgmtFrameInProgress = new AtomicBoolean(false); |
| private boolean mIsEnhancedOpenSupportedInitialized = false; |
| private boolean mIsEnhancedOpenSupported; |
| |
| private class ScanEventHandler extends IScanEvent.Stub { |
| private String mIfaceName; |
| |
| ScanEventHandler(@NonNull String ifaceName) { |
| mIfaceName = ifaceName; |
| } |
| |
| @Override |
| public void OnScanResultReady() { |
| Log.d(TAG, "Scan result ready event"); |
| mWifiMonitor.broadcastScanResultEvent(mIfaceName); |
| } |
| |
| @Override |
| public void OnScanFailed() { |
| Log.d(TAG, "Scan failed event"); |
| mWifiMonitor.broadcastScanFailedEvent(mIfaceName); |
| } |
| } |
| |
| WificondControl(WifiInjector wifiInjector, WifiMonitor wifiMonitor, |
| CarrierNetworkConfig carrierNetworkConfig, AlarmManager alarmManager, Looper looper, |
| Clock clock) { |
| mWifiInjector = wifiInjector; |
| mWifiMonitor = wifiMonitor; |
| mCarrierNetworkConfig = carrierNetworkConfig; |
| mAlarmManager = alarmManager; |
| mEventHandler = new Handler(looper); |
| mClock = clock; |
| } |
| |
| private class PnoScanEventHandler extends IPnoScanEvent.Stub { |
| private String mIfaceName; |
| |
| PnoScanEventHandler(@NonNull String ifaceName) { |
| mIfaceName = ifaceName; |
| } |
| |
| @Override |
| public void OnPnoNetworkFound() { |
| Log.d(TAG, "Pno scan result event"); |
| mWifiMonitor.broadcastPnoScanResultEvent(mIfaceName); |
| mWifiInjector.getWifiMetrics().incrementPnoFoundNetworkEventCount(); |
| } |
| |
| @Override |
| public void OnPnoScanFailed() { |
| Log.d(TAG, "Pno Scan failed event"); |
| mWifiInjector.getWifiMetrics().incrementPnoScanFailedCount(); |
| } |
| |
| @Override |
| public void OnPnoScanOverOffloadStarted() { |
| Log.d(TAG, "Pno scan over offload started"); |
| mWifiInjector.getWifiMetrics().incrementPnoScanStartedOverOffloadCount(); |
| } |
| |
| @Override |
| public void OnPnoScanOverOffloadFailed(int reason) { |
| Log.d(TAG, "Pno scan over offload failed"); |
| mWifiInjector.getWifiMetrics().incrementPnoScanFailedOverOffloadCount(); |
| } |
| } |
| |
| /** |
| * Listener for AP Interface events. |
| */ |
| private class ApInterfaceEventCallback extends IApInterfaceEventCallback.Stub { |
| private SoftApListener mSoftApListener; |
| |
| ApInterfaceEventCallback(SoftApListener listener) { |
| mSoftApListener = listener; |
| } |
| |
| @Override |
| public void onNumAssociatedStationsChanged(int numStations) { |
| mSoftApListener.onNumAssociatedStationsChanged(numStations); |
| } |
| |
| @Override |
| public void onSoftApChannelSwitched(int frequency, int bandwidth) { |
| mSoftApListener.onSoftApChannelSwitched(frequency, bandwidth); |
| } |
| } |
| |
| /** |
| * Callback triggered by wificond. |
| */ |
| private class SendMgmtFrameEvent extends ISendMgmtFrameEvent.Stub { |
| private SendMgmtFrameCallback mCallback; |
| private AlarmManager.OnAlarmListener mTimeoutCallback; |
| /** |
| * ensures that mCallback is only called once |
| */ |
| private boolean mWasCalled; |
| |
| private void runIfFirstCall(Runnable r) { |
| if (mWasCalled) return; |
| mWasCalled = true; |
| |
| mSendMgmtFrameInProgress.set(false); |
| r.run(); |
| } |
| |
| SendMgmtFrameEvent(@NonNull SendMgmtFrameCallback callback) { |
| mCallback = callback; |
| // called in main thread |
| mTimeoutCallback = () -> runIfFirstCall(() -> { |
| if (mVerboseLoggingEnabled) { |
| Log.e(TAG, "Timed out waiting for ACK"); |
| } |
| mCallback.onFailure(WifiNative.SEND_MGMT_FRAME_ERROR_TIMEOUT); |
| }); |
| mWasCalled = false; |
| |
| mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, |
| mClock.getElapsedSinceBootMillis() + SEND_MGMT_FRAME_TIMEOUT_MS, |
| TIMEOUT_ALARM_TAG, mTimeoutCallback, mEventHandler); |
| } |
| |
| // called in binder thread |
| @Override |
| public void OnAck(int elapsedTimeMs) { |
| // post to main thread |
| mEventHandler.post(() -> runIfFirstCall(() -> { |
| mAlarmManager.cancel(mTimeoutCallback); |
| mCallback.onAck(elapsedTimeMs); |
| })); |
| } |
| |
| // called in binder thread |
| @Override |
| public void OnFailure(int reason) { |
| // post to main thread |
| mEventHandler.post(() -> runIfFirstCall(() -> { |
| mAlarmManager.cancel(mTimeoutCallback); |
| mCallback.onFailure(reason); |
| })); |
| } |
| } |
| |
| /** |
| * Called by the binder subsystem upon remote object death. |
| * Invoke all the register death handlers and clear state. |
| */ |
| @Override |
| public void binderDied() { |
| mEventHandler.post(() -> { |
| Log.e(TAG, "Wificond died!"); |
| clearState(); |
| // Invalidate the global wificond handle on death. Will be refreshed |
| // on the next setup call. |
| mWificond = null; |
| if (mDeathEventHandler != null) { |
| mDeathEventHandler.onDeath(); |
| } |
| }); |
| } |
| |
| /** Enable or disable verbose logging of WificondControl. |
| * @param enable True to enable verbose logging. False to disable verbose logging. |
| */ |
| public void enableVerboseLogging(boolean enable) { |
| mVerboseLoggingEnabled = enable; |
| } |
| |
| /** |
| * Initializes wificond & registers a death notification for wificond. |
| * This method clears any existing state in wificond daemon. |
| * |
| * @return Returns true on success. |
| */ |
| public boolean initialize(@NonNull WifiNative.WificondDeathEventHandler handler) { |
| if (mDeathEventHandler != null) { |
| Log.e(TAG, "Death handler already present"); |
| } |
| mDeathEventHandler = handler; |
| tearDownInterfaces(); |
| return true; |
| } |
| |
| /** |
| * Helper method to retrieve the global wificond handle and register for |
| * death notifications. |
| */ |
| private boolean retrieveWificondAndRegisterForDeath() { |
| if (mWificond != null) { |
| if (mVerboseLoggingEnabled) { |
| Log.d(TAG, "Wificond handle already retrieved"); |
| } |
| // We already have a wificond handle. |
| return true; |
| } |
| mWificond = mWifiInjector.makeWificond(); |
| if (mWificond == null) { |
| Log.e(TAG, "Failed to get reference to wificond"); |
| return false; |
| } |
| try { |
| mWificond.asBinder().linkToDeath(this, 0); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to register death notification for wificond"); |
| // The remote has already died. |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Setup interface for client mode via wificond. |
| * @return An IClientInterface as wificond client interface binder handler. |
| * Returns null on failure. |
| */ |
| public IClientInterface setupInterfaceForClientMode(@NonNull String ifaceName) { |
| Log.d(TAG, "Setting up interface for client mode"); |
| if (!retrieveWificondAndRegisterForDeath()) { |
| return null; |
| } |
| |
| IClientInterface clientInterface = null; |
| try { |
| clientInterface = mWificond.createClientInterface(ifaceName); |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to get IClientInterface due to remote exception"); |
| return null; |
| } |
| |
| if (clientInterface == null) { |
| Log.e(TAG, "Could not get IClientInterface instance from wificond"); |
| return null; |
| } |
| Binder.allowBlocking(clientInterface.asBinder()); |
| |
| // Refresh Handlers |
| mClientInterfaces.put(ifaceName, clientInterface); |
| try { |
| IWifiScannerImpl wificondScanner = clientInterface.getWifiScannerImpl(); |
| if (wificondScanner == null) { |
| Log.e(TAG, "Failed to get WificondScannerImpl"); |
| return null; |
| } |
| mWificondScanners.put(ifaceName, wificondScanner); |
| Binder.allowBlocking(wificondScanner.asBinder()); |
| ScanEventHandler scanEventHandler = new ScanEventHandler(ifaceName); |
| mScanEventHandlers.put(ifaceName, scanEventHandler); |
| wificondScanner.subscribeScanEvents(scanEventHandler); |
| PnoScanEventHandler pnoScanEventHandler = new PnoScanEventHandler(ifaceName); |
| mPnoScanEventHandlers.put(ifaceName, pnoScanEventHandler); |
| wificondScanner.subscribePnoScanEvents(pnoScanEventHandler); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to refresh wificond scanner due to remote exception"); |
| } |
| |
| return clientInterface; |
| } |
| |
| /** |
| * Teardown a specific STA interface configured in wificond. |
| * |
| * @return Returns true on success. |
| */ |
| public boolean tearDownClientInterface(@NonNull String ifaceName) { |
| if (getClientInterface(ifaceName) == null) { |
| Log.e(TAG, "No valid wificond client interface handler"); |
| return false; |
| } |
| try { |
| IWifiScannerImpl scannerImpl = mWificondScanners.get(ifaceName); |
| if (scannerImpl != null) { |
| scannerImpl.unsubscribeScanEvents(); |
| scannerImpl.unsubscribePnoScanEvents(); |
| } |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to unsubscribe wificond scanner due to remote exception"); |
| return false; |
| } |
| |
| boolean success; |
| try { |
| success = mWificond.tearDownClientInterface(ifaceName); |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to teardown client interface due to remote exception"); |
| return false; |
| } |
| if (!success) { |
| Log.e(TAG, "Failed to teardown client interface"); |
| return false; |
| } |
| |
| mClientInterfaces.remove(ifaceName); |
| mWificondScanners.remove(ifaceName); |
| mScanEventHandlers.remove(ifaceName); |
| mPnoScanEventHandlers.remove(ifaceName); |
| return true; |
| } |
| |
| /** |
| * Setup interface for softAp mode via wificond. |
| * @return An IApInterface as wificond Ap interface binder handler. |
| * Returns null on failure. |
| */ |
| public IApInterface setupInterfaceForSoftApMode(@NonNull String ifaceName) { |
| Log.d(TAG, "Setting up interface for soft ap mode"); |
| if (!retrieveWificondAndRegisterForDeath()) { |
| return null; |
| } |
| |
| IApInterface apInterface = null; |
| try { |
| apInterface = mWificond.createApInterface(ifaceName); |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to get IApInterface due to remote exception"); |
| return null; |
| } |
| |
| if (apInterface == null) { |
| Log.e(TAG, "Could not get IApInterface instance from wificond"); |
| return null; |
| } |
| Binder.allowBlocking(apInterface.asBinder()); |
| |
| // Refresh Handlers |
| mApInterfaces.put(ifaceName, apInterface); |
| return apInterface; |
| } |
| |
| /** |
| * Teardown a specific AP interface configured in wificond. |
| * |
| * @return Returns true on success. |
| */ |
| public boolean tearDownSoftApInterface(@NonNull String ifaceName) { |
| if (getApInterface(ifaceName) == null) { |
| Log.e(TAG, "No valid wificond ap interface handler"); |
| return false; |
| } |
| boolean success; |
| try { |
| success = mWificond.tearDownApInterface(ifaceName); |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to teardown AP interface due to remote exception"); |
| return false; |
| } |
| if (!success) { |
| Log.e(TAG, "Failed to teardown AP interface"); |
| return false; |
| } |
| mApInterfaces.remove(ifaceName); |
| mApInterfaceListeners.remove(ifaceName); |
| return true; |
| } |
| |
| /** |
| * Teardown all interfaces configured in wificond. |
| * @return Returns true on success. |
| */ |
| public boolean tearDownInterfaces() { |
| Log.d(TAG, "tearing down interfaces in wificond"); |
| // Explicitly refresh the wificodn handler because |tearDownInterfaces()| |
| // could be used to cleanup before we setup any interfaces. |
| if (!retrieveWificondAndRegisterForDeath()) { |
| return false; |
| } |
| |
| try { |
| for (Map.Entry<String, IWifiScannerImpl> entry : mWificondScanners.entrySet()) { |
| entry.getValue().unsubscribeScanEvents(); |
| entry.getValue().unsubscribePnoScanEvents(); |
| } |
| mWificond.tearDownInterfaces(); |
| clearState(); |
| return true; |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to tear down interfaces due to remote exception"); |
| } |
| |
| return false; |
| } |
| |
| /** Helper function to look up the interface handle using name */ |
| private IClientInterface getClientInterface(@NonNull String ifaceName) { |
| return mClientInterfaces.get(ifaceName); |
| } |
| |
| /** |
| * Request signal polling to wificond. |
| * @param ifaceName Name of the interface. |
| * Returns an SignalPollResult object. |
| * Returns null on failure. |
| */ |
| public WifiNative.SignalPollResult signalPoll(@NonNull String ifaceName) { |
| IClientInterface iface = getClientInterface(ifaceName); |
| if (iface == null) { |
| Log.e(TAG, "No valid wificond client interface handler"); |
| return null; |
| } |
| |
| int[] resultArray; |
| try { |
| resultArray = iface.signalPoll(); |
| if (resultArray == null || resultArray.length != 4) { |
| Log.e(TAG, "Invalid signal poll result from wificond"); |
| return null; |
| } |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to do signal polling due to remote exception"); |
| return null; |
| } |
| WifiNative.SignalPollResult pollResult = new WifiNative.SignalPollResult(); |
| pollResult.currentRssi = resultArray[0]; |
| pollResult.txBitrate = resultArray[1]; |
| pollResult.associationFrequency = resultArray[2]; |
| pollResult.rxBitrate = resultArray[3]; |
| return pollResult; |
| } |
| |
| /** |
| * Fetch TX packet counters on current connection from wificond. |
| * @param ifaceName Name of the interface. |
| * Returns an TxPacketCounters object. |
| * Returns null on failure. |
| */ |
| public WifiNative.TxPacketCounters getTxPacketCounters(@NonNull String ifaceName) { |
| IClientInterface iface = getClientInterface(ifaceName); |
| if (iface == null) { |
| Log.e(TAG, "No valid wificond client interface handler"); |
| return null; |
| } |
| |
| int[] resultArray; |
| try { |
| resultArray = iface.getPacketCounters(); |
| if (resultArray == null || resultArray.length != 2) { |
| Log.e(TAG, "Invalid signal poll result from wificond"); |
| return null; |
| } |
| } catch (RemoteException e) { |
| Log.e(TAG, "Failed to do signal polling due to remote exception"); |
| return null; |
| } |
| WifiNative.TxPacketCounters counters = new WifiNative.TxPacketCounters(); |
| counters.txSucceeded = resultArray[0]; |
| counters.txFailed = resultArray[1]; |
| return counters; |
| } |
| |
| /** Helper function to look up the scanner impl handle using name */ |
| private IWifiScannerImpl getScannerImpl(@NonNull String ifaceName) { |
| return mWificondScanners.get(ifaceName); |
| } |
| |
| /** |
| * Fetch the latest scan result from kernel via wificond. |
| * @param ifaceName Name of the interface. |
| * @return Returns an ArrayList of ScanDetail. |
| * Returns an empty ArrayList on failure. |
| */ |
| public ArrayList<ScanDetail> getScanResults(@NonNull String ifaceName, int scanType) { |
| ArrayList<ScanDetail> results = new ArrayList<>(); |
| IWifiScannerImpl scannerImpl = getScannerImpl(ifaceName); |
| if (scannerImpl == null) { |
| Log.e(TAG, "No valid wificond scanner interface handler"); |
| return results; |
| } |
| try { |
| NativeScanResult[] nativeResults; |
| if (scanType == SCAN_TYPE_SINGLE_SCAN) { |
| nativeResults = scannerImpl.getScanResults(); |
| } else { |
| nativeResults = scannerImpl.getPnoScanResults(); |
| } |
| for (NativeScanResult result : nativeResults) { |
| WifiSsid wifiSsid = WifiSsid.createFromByteArray(result.ssid); |
| String bssid; |
| try { |
| bssid = NativeUtil.macAddressFromByteArray(result.bssid); |
| } catch (IllegalArgumentException e) { |
| Log.e(TAG, "Illegal argument " + result.bssid, e); |
| continue; |
| } |
| if (bssid == null) { |
| Log.e(TAG, "Illegal null bssid"); |
| continue; |
| } |
| ScanResult.InformationElement[] ies = |
| InformationElementUtil.parseInformationElements(result.infoElement); |
| InformationElementUtil.Capabilities capabilities = |
| new InformationElementUtil.Capabilities(); |
| capabilities.from(ies, result.capability, isEnhancedOpenSupported()); |
| String flags = capabilities.generateCapabilitiesString(); |
| NetworkDetail networkDetail; |
| try { |
| networkDetail = new NetworkDetail(bssid, ies, null, result.frequency); |
| } catch (IllegalArgumentException e) { |
| Log.e(TAG, "Illegal argument for scan result with bssid: " + bssid, e); |
| continue; |
| } |
| |
| ScanDetail scanDetail = new ScanDetail(networkDetail, wifiSsid, bssid, flags, |
| result.signalMbm / 100, result.frequency, result.tsf, ies, null); |
| ScanResult scanResult = scanDetail.getScanResult(); |
| // Update carrier network info if this AP's SSID is associated with a carrier Wi-Fi |
| // network and it uses EAP. |
| if (ScanResultUtil.isScanResultForEapNetwork(scanDetail.getScanResult()) |
| && mCarrierNetworkConfig.isCarrierNetwork(wifiSsid.toString())) { |
| scanResult.isCarrierAp = true; |
| scanResult.carrierApEapType = |
| mCarrierNetworkConfig.getNetworkEapType(wifiSsid.toString()); |
| scanResult.carrierName = |
| mCarrierNetworkConfig.getCarrierName(wifiSsid.toString()); |
| } |
| // Fill up the radio chain info. |
| if (result.radioChainInfos != null) { |
| scanResult.radioChainInfos = |
| new ScanResult.RadioChainInfo[result.radioChainInfos.size()]; |
| int idx = 0; |
| for (RadioChainInfo nativeRadioChainInfo : result.radioChainInfos) { |
| scanResult.radioChainInfos[idx] = new ScanResult.RadioChainInfo(); |
| scanResult.radioChainInfos[idx].id = nativeRadioChainInfo.chainId; |
| scanResult.radioChainInfos[idx].level = nativeRadioChainInfo.level; |
| idx++; |
| } |
| } |
| results.add(scanDetail); |
| } |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to create ScanDetail ArrayList"); |
| } |
| if (mVerboseLoggingEnabled) { |
| Log.d(TAG, "get " + results.size() + " scan results from wificond"); |
| } |
| |
| return results; |
| } |
| |
| /** |
| * Return scan type for the parcelable {@link SingleScanSettings} |
| */ |
| private static int getScanType(int scanType) { |
| switch (scanType) { |
| case WifiNative.SCAN_TYPE_LOW_LATENCY: |
| return IWifiScannerImpl.SCAN_TYPE_LOW_SPAN; |
| case WifiNative.SCAN_TYPE_LOW_POWER: |
| return IWifiScannerImpl.SCAN_TYPE_LOW_POWER; |
| case WifiNative.SCAN_TYPE_HIGH_ACCURACY: |
| return IWifiScannerImpl.SCAN_TYPE_HIGH_ACCURACY; |
| default: |
| throw new IllegalArgumentException("Invalid scan type " + scanType); |
| } |
| } |
| |
| /** |
| * Start a scan using wificond for the given parameters. |
| * @param ifaceName Name of the interface. |
| * @param scanType Type of scan to perform. |
| * @param freqs list of frequencies to scan for, if null scan all supported channels. |
| * @param hiddenNetworkSSIDs List of hidden networks to be scanned for. |
| * @return Returns true on success. |
| */ |
| public boolean scan(@NonNull String ifaceName, |
| int scanType, |
| Set<Integer> freqs, |
| List<String> hiddenNetworkSSIDs) { |
| IWifiScannerImpl scannerImpl = getScannerImpl(ifaceName); |
| if (scannerImpl == null) { |
| Log.e(TAG, "No valid wificond scanner interface handler"); |
| return false; |
| } |
| SingleScanSettings settings = new SingleScanSettings(); |
| try { |
| settings.scanType = getScanType(scanType); |
| } catch (IllegalArgumentException e) { |
| Log.e(TAG, "Invalid scan type ", e); |
| return false; |
| } |
| settings.channelSettings = new ArrayList<>(); |
| settings.hiddenNetworks = new ArrayList<>(); |
| |
| if (freqs != null) { |
| for (Integer freq : freqs) { |
| ChannelSettings channel = new ChannelSettings(); |
| channel.frequency = freq; |
| settings.channelSettings.add(channel); |
| } |
| } |
| if (hiddenNetworkSSIDs != null) { |
| for (String ssid : hiddenNetworkSSIDs) { |
| HiddenNetwork network = new HiddenNetwork(); |
| try { |
| network.ssid = NativeUtil.byteArrayFromArrayList(NativeUtil.decodeSsid(ssid)); |
| } catch (IllegalArgumentException e) { |
| Log.e(TAG, "Illegal argument " + ssid, e); |
| continue; |
| } |
| // settings.hiddenNetworks is expected to be very small, so this shouldn't cause |
| // any performance issues. |
| if (!settings.hiddenNetworks.contains(network)) { |
| settings.hiddenNetworks.add(network); |
| } |
| } |
| } |
| |
| try { |
| return scannerImpl.scan(settings); |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to request scan due to remote exception"); |
| } |
| return false; |
| } |
| |
| /** |
| * Start PNO scan. |
| * @param ifaceName Name of the interface. |
| * @param pnoSettings Pno scan configuration. |
| * @return true on success. |
| */ |
| public boolean startPnoScan(@NonNull String ifaceName, WifiNative.PnoSettings pnoSettings) { |
| IWifiScannerImpl scannerImpl = getScannerImpl(ifaceName); |
| if (scannerImpl == null) { |
| Log.e(TAG, "No valid wificond scanner interface handler"); |
| return false; |
| } |
| PnoSettings settings = new PnoSettings(); |
| settings.pnoNetworks = new ArrayList<>(); |
| settings.intervalMs = pnoSettings.periodInMs; |
| settings.min2gRssi = pnoSettings.min24GHzRssi; |
| settings.min5gRssi = pnoSettings.min5GHzRssi; |
| if (pnoSettings.networkList != null) { |
| for (WifiNative.PnoNetwork network : pnoSettings.networkList) { |
| PnoNetwork condNetwork = new PnoNetwork(); |
| condNetwork.isHidden = (network.flags |
| & WifiScanner.PnoSettings.PnoNetwork.FLAG_DIRECTED_SCAN) != 0; |
| try { |
| condNetwork.ssid = |
| NativeUtil.byteArrayFromArrayList(NativeUtil.decodeSsid(network.ssid)); |
| } catch (IllegalArgumentException e) { |
| Log.e(TAG, "Illegal argument " + network.ssid, e); |
| continue; |
| } |
| condNetwork.frequencies = network.frequencies; |
| settings.pnoNetworks.add(condNetwork); |
| } |
| } |
| |
| try { |
| boolean success = scannerImpl.startPnoScan(settings); |
| mWifiInjector.getWifiMetrics().incrementPnoScanStartAttempCount(); |
| if (!success) { |
| mWifiInjector.getWifiMetrics().incrementPnoScanFailedCount(); |
| } |
| return success; |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to start pno scan due to remote exception"); |
| } |
| return false; |
| } |
| |
| /** |
| * Stop PNO scan. |
| * @param ifaceName Name of the interface. |
| * @return true on success. |
| */ |
| public boolean stopPnoScan(@NonNull String ifaceName) { |
| IWifiScannerImpl scannerImpl = getScannerImpl(ifaceName); |
| if (scannerImpl == null) { |
| Log.e(TAG, "No valid wificond scanner interface handler"); |
| return false; |
| } |
| try { |
| return scannerImpl.stopPnoScan(); |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to stop pno scan due to remote exception"); |
| } |
| return false; |
| } |
| |
| /** |
| * Abort ongoing single scan. |
| * @param ifaceName Name of the interface. |
| */ |
| public void abortScan(@NonNull String ifaceName) { |
| IWifiScannerImpl scannerImpl = getScannerImpl(ifaceName); |
| if (scannerImpl == null) { |
| Log.e(TAG, "No valid wificond scanner interface handler"); |
| return; |
| } |
| try { |
| scannerImpl.abortScan(); |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to request abortScan due to remote exception"); |
| } |
| } |
| |
| /** |
| * Query the list of valid frequencies for the provided band. |
| * The result depends on the on the country code that has been set. |
| * |
| * @param band as specified by one of the WifiScanner.WIFI_BAND_* constants. |
| * The following bands are supported: |
| * WifiScanner.WIFI_BAND_24_GHZ |
| * WifiScanner.WIFI_BAND_5_GHZ |
| * WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY |
| * @return frequencies vector of valid frequencies (MHz), or null for error. |
| * @throws IllegalArgumentException if band is not recognized. |
| */ |
| public int [] getChannelsForBand(int band) { |
| if (mWificond == null) { |
| Log.e(TAG, "No valid wificond scanner interface handler"); |
| return null; |
| } |
| try { |
| switch (band) { |
| case WifiScanner.WIFI_BAND_24_GHZ: |
| return mWificond.getAvailable2gChannels(); |
| case WifiScanner.WIFI_BAND_5_GHZ: |
| return mWificond.getAvailable5gNonDFSChannels(); |
| case WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY: |
| return mWificond.getAvailableDFSChannels(); |
| default: |
| throw new IllegalArgumentException("unsupported band " + band); |
| } |
| } catch (RemoteException e1) { |
| Log.e(TAG, "Failed to request getChannelsForBand due to remote exception"); |
| } |
| return null; |
| } |
| |
| /** Helper function to look up the interface handle using name */ |
| private IApInterface getApInterface(@NonNull String ifaceName) { |
| return mApInterfaces.get(ifaceName); |
| } |
| |
| /** |
| * Register the provided listener for SoftAp events. |
| * |
| * @param ifaceName Name of the interface. |
| * @param listener Callback for AP events. |
| * @return true on success, false otherwise. |
| */ |
| public boolean registerApListener(@NonNull String ifaceName, SoftApListener listener) { |
| IApInterface iface = getApInterface(ifaceName); |
| if (iface == null) { |
| Log.e(TAG, "No valid ap interface handler"); |
| return false; |
| } |
| try { |
| IApInterfaceEventCallback callback = new ApInterfaceEventCallback(listener); |
| mApInterfaceListeners.put(ifaceName, callback); |
| boolean success = iface.registerCallback(callback); |
| if (!success) { |
| Log.e(TAG, "Failed to register ap callback."); |
| return false; |
| } |
| } catch (RemoteException e) { |
| Log.e(TAG, "Exception in registering AP callback: " + e); |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * See {@link WifiNative#sendMgmtFrame(String, byte[], SendMgmtFrameCallback, int)} |
| */ |
| public void sendMgmtFrame(@NonNull String ifaceName, @NonNull byte[] frame, |
| @NonNull SendMgmtFrameCallback callback, int mcs) { |
| |
| if (callback == null) { |
| Log.e(TAG, "callback cannot be null!"); |
| return; |
| } |
| |
| if (frame == null) { |
| Log.e(TAG, "frame cannot be null!"); |
| callback.onFailure(WifiNative.SEND_MGMT_FRAME_ERROR_UNKNOWN); |
| return; |
| } |
| |
| // TODO (b/112029045) validate mcs |
| IClientInterface clientInterface = getClientInterface(ifaceName); |
| if (clientInterface == null) { |
| Log.e(TAG, "No valid wificond client interface handler"); |
| callback.onFailure(WifiNative.SEND_MGMT_FRAME_ERROR_UNKNOWN); |
| return; |
| } |
| |
| if (!mSendMgmtFrameInProgress.compareAndSet(false, true)) { |
| Log.e(TAG, "An existing management frame transmission is in progress!"); |
| callback.onFailure(WifiNative.SEND_MGMT_FRAME_ERROR_ALREADY_STARTED); |
| return; |
| } |
| |
| SendMgmtFrameEvent sendMgmtFrameEvent = new SendMgmtFrameEvent(callback); |
| try { |
| clientInterface.SendMgmtFrame(frame, sendMgmtFrameEvent, mcs); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Exception while starting link probe: " + e); |
| // Call sendMgmtFrameEvent.OnFailure() instead of callback.onFailure() so that |
| // sendMgmtFrameEvent can clean up internal state, such as cancelling the timer. |
| sendMgmtFrameEvent.OnFailure(WifiNative.SEND_MGMT_FRAME_ERROR_UNKNOWN); |
| } |
| } |
| |
| /** |
| * Clear all internal handles. |
| */ |
| private void clearState() { |
| // Refresh handlers |
| mClientInterfaces.clear(); |
| mWificondScanners.clear(); |
| mPnoScanEventHandlers.clear(); |
| mScanEventHandlers.clear(); |
| mApInterfaces.clear(); |
| mApInterfaceListeners.clear(); |
| mSendMgmtFrameInProgress.set(false); |
| } |
| |
| /** |
| * Check if OWE (Enhanced Open) is supported on the device |
| * |
| * @return true if OWE is supported |
| */ |
| private boolean isEnhancedOpenSupported() { |
| if (mIsEnhancedOpenSupportedInitialized) { |
| return mIsEnhancedOpenSupported; |
| } |
| |
| // WifiNative handle might be null, check this here |
| if (mWifiNative == null) { |
| mWifiNative = mWifiInjector.getWifiNative(); |
| if (mWifiNative == null) { |
| return false; |
| } |
| } |
| |
| String iface = mWifiNative.getClientInterfaceName(); |
| if (iface == null) { |
| // Client interface might not be initialized during boot or Wi-Fi off |
| return false; |
| } |
| |
| mIsEnhancedOpenSupportedInitialized = true; |
| mIsEnhancedOpenSupported = (mWifiNative.getSupportedFeatureSet(iface) |
| & WIFI_FEATURE_OWE) != 0; |
| return mIsEnhancedOpenSupported; |
| } |
| } |