/* * Copyright (C) 2016 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.aware; import android.net.MacAddress; import android.net.wifi.aware.AwareParams; import android.net.wifi.aware.ConfigRequest; import android.net.wifi.aware.PublishConfig; import android.net.wifi.aware.SubscribeConfig; import android.net.wifi.aware.WifiAwareDataPathSecurityConfig; import android.net.wifi.util.HexEncoding; import android.util.ArrayMap; import android.util.Log; import android.util.SparseIntArray; import com.android.modules.utils.BasicShellCommandHandler; import com.android.server.wifi.hal.WifiNanIface; import com.android.server.wifi.hal.WifiNanIface.PowerParameters; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.Arrays; import java.util.HashMap; import java.util.Map; /** * Translates Wi-Fi Aware requests from the framework to the HAL. * * Delegates the management of the NAN interface to WifiAwareNativeManager. */ public class WifiAwareNativeApi implements WifiAwareShellCommand.DelegatedShellCommand { private static final String TAG = "WifiAwareNativeApi"; private boolean mVdbg = false; // STOPSHIP if true private boolean mVerboseLoggingEnabled = false; private final WifiAwareNativeManager mHal; private SparseIntArray mTransactionIds; // VDBG only! public WifiAwareNativeApi(WifiAwareNativeManager wifiAwareNativeManager) { mHal = wifiAwareNativeManager; onReset(); } /** * Enable/Disable verbose logging. * */ public void enableVerboseLogging(boolean verboseEnabled, boolean vDbg) { mVerboseLoggingEnabled = verboseEnabled; mVdbg = vDbg; } private void recordTransactionId(int transactionId) { if (!mVdbg) return; if (transactionId == 0) { return; // tid == 0 is used as a placeholder transaction ID in several commands } if (mTransactionIds == null) { mTransactionIds = new SparseIntArray(); } int count = mTransactionIds.get(transactionId); if (count != 0) { Log.wtf(TAG, "Repeated transaction ID == " + transactionId); } mTransactionIds.append(transactionId, count + 1); } /* * Parameters settable through the shell command. * see wifi/1.0/types.hal NanBandSpecificConfig.discoveryWindowIntervalVal and * wifi/1.2/types.hal NanConfigRequestSupplemental_1_2 for description */ /* package */ static final String POWER_PARAM_DEFAULT_KEY = "default"; /* package */ static final String POWER_PARAM_INACTIVE_KEY = "inactive"; /* package */ static final String POWER_PARAM_IDLE_KEY = "idle"; /* package */ static final String PARAM_DW_24GHZ = "dw_24ghz"; private static final int PARAM_DW_24GHZ_DEFAULT = 1; // 1 -> DW=1, latency=512ms private static final int PARAM_DW_24GHZ_INACTIVE = 4; // 4 -> DW=8, latency=4s private static final int PARAM_DW_24GHZ_IDLE = 4; // == inactive /* package */ static final String PARAM_DW_5GHZ = "dw_5ghz"; private static final int PARAM_DW_5GHZ_DEFAULT = 1; // 1 -> DW=1, latency=512ms private static final int PARAM_DW_5GHZ_INACTIVE = 0; // 0 = disabled private static final int PARAM_DW_5GHZ_IDLE = 0; // == inactive /* package */ static final String PARAM_DW_6GHZ = "dw_6ghz"; private static final int PARAM_DW_6GHZ_DEFAULT = 1; // 1 -> DW=1, latency=512ms private static final int PARAM_DW_6GHZ_INACTIVE = 0; // 0 = disabled private static final int PARAM_DW_6GHZ_IDLE = 0; // == inactive /* package */ static final String PARAM_DISCOVERY_BEACON_INTERVAL_MS = "disc_beacon_interval_ms"; private static final int PARAM_DISCOVERY_BEACON_INTERVAL_MS_DEFAULT = 0; // Firmware defaults private static final int PARAM_DISCOVERY_BEACON_INTERVAL_MS_INACTIVE = 0; // Firmware defaults private static final int PARAM_DISCOVERY_BEACON_INTERVAL_MS_IDLE = 0; // Firmware defaults /* package */ static final String PARAM_NUM_SS_IN_DISCOVERY = "num_ss_in_discovery"; private static final int PARAM_NUM_SS_IN_DISCOVERY_DEFAULT = 0; // Firmware defaults private static final int PARAM_NUM_SS_IN_DISCOVERY_INACTIVE = 0; // Firmware defaults private static final int PARAM_NUM_SS_IN_DISCOVERY_IDLE = 0; // Firmware defaults /* package */ static final String PARAM_ENABLE_DW_EARLY_TERM = "enable_dw_early_term"; private static final int PARAM_ENABLE_DW_EARLY_TERM_DEFAULT = 0; // boolean: 0 = false private static final int PARAM_ENABLE_DW_EARLY_TERM_INACTIVE = 0; // boolean: 0 = false private static final int PARAM_ENABLE_DW_EARLY_TERM_IDLE = 0; // boolean: 0 = false /* package */ static final String PARAM_MAC_RANDOM_INTERVAL_SEC = "mac_random_interval_sec"; private static final int PARAM_MAC_RANDOM_INTERVAL_SEC_DEFAULT = 1800; // 30 minutes private final Map> mSettablePowerParameters = new HashMap<>(); private final Map mSettableParameters = new HashMap<>(); private final Map mExternalSetParams = new ArrayMap<>(); /** * Accept using parameter from external to config the Aware */ public void setAwareParams(AwareParams parameters) { mExternalSetParams.clear(); if (parameters == null) { return; } if (mVerboseLoggingEnabled) { Log.v(TAG, "setting Aware Parameters=" + parameters); } if (parameters.getDiscoveryWindowWakeInterval24Ghz() > 0 && parameters.getDiscoveryWindowWakeInterval24Ghz() <= 5) { mExternalSetParams.put(PARAM_DW_24GHZ, parameters.getDiscoveryWindowWakeInterval24Ghz()); } if (parameters.getDiscoveryWindowWakeInterval5Ghz() >= 0 && parameters.getDiscoveryWindowWakeInterval5Ghz() <= 5) { mExternalSetParams.put(PARAM_DW_5GHZ, parameters.getDiscoveryWindowWakeInterval5Ghz()); } if (parameters.getDiscoveryBeaconIntervalMillis() > 0) { mExternalSetParams.put(PARAM_DISCOVERY_BEACON_INTERVAL_MS, parameters.getDiscoveryBeaconIntervalMillis()); } if (parameters.getNumSpatialStreamsInDiscovery() > 0) { mExternalSetParams.put(PARAM_NUM_SS_IN_DISCOVERY, parameters.getNumSpatialStreamsInDiscovery()); } if (parameters.getMacRandomizationIntervalSeconds() > 0 && parameters.getMacRandomizationIntervalSeconds() <= 1800) { mExternalSetParams.put(PARAM_MAC_RANDOM_INTERVAL_SEC, parameters.getMacRandomizationIntervalSeconds()); } if (parameters.isDwEarlyTerminationEnabled()) { mExternalSetParams.put(PARAM_ENABLE_DW_EARLY_TERM, 1); } } /** * Interpreter of adb shell command 'adb shell wifiaware native_api ...'. * * @return -1 if parameter not recognized or invalid value, 0 otherwise. */ @Override public int onCommand(BasicShellCommandHandler parentShell) { final PrintWriter pw = parentShell.getErrPrintWriter(); String subCmd = parentShell.getNextArgRequired(); if (mVdbg) Log.v(TAG, "onCommand: subCmd='" + subCmd + "'"); switch (subCmd) { case "set": { String name = parentShell.getNextArgRequired(); if (mVdbg) Log.v(TAG, "onCommand: name='" + name + "'"); if (!mSettableParameters.containsKey(name)) { pw.println("Unknown parameter name -- '" + name + "'"); return -1; } String valueStr = parentShell.getNextArgRequired(); if (mVdbg) Log.v(TAG, "onCommand: valueStr='" + valueStr + "'"); int value; try { value = Integer.valueOf(valueStr); } catch (NumberFormatException e) { pw.println("Can't convert value to integer -- '" + valueStr + "'"); return -1; } mSettableParameters.put(name, value); return 0; } case "set-power": { String mode = parentShell.getNextArgRequired(); String name = parentShell.getNextArgRequired(); String valueStr = parentShell.getNextArgRequired(); if (mVdbg) { Log.v(TAG, "onCommand: mode='" + mode + "', name='" + name + "'" + ", value='" + valueStr + "'"); } if (!mSettablePowerParameters.containsKey(mode)) { pw.println("Unknown mode name -- '" + mode + "'"); return -1; } if (!mSettablePowerParameters.get(mode).containsKey(name)) { pw.println("Unknown parameter name '" + name + "' in mode '" + mode + "'"); return -1; } int value; try { value = Integer.valueOf(valueStr); } catch (NumberFormatException e) { pw.println("Can't convert value to integer -- '" + valueStr + "'"); return -1; } mSettablePowerParameters.get(mode).put(name, value); return 0; } case "get": { String name = parentShell.getNextArgRequired(); if (mVdbg) Log.v(TAG, "onCommand: name='" + name + "'"); if (!mSettableParameters.containsKey(name)) { pw.println("Unknown parameter name -- '" + name + "'"); return -1; } parentShell.getOutPrintWriter().println((int) mSettableParameters.get(name)); return 0; } case "get-power": { String mode = parentShell.getNextArgRequired(); String name = parentShell.getNextArgRequired(); if (mVdbg) Log.v(TAG, "onCommand: mode='" + mode + "', name='" + name + "'"); if (!mSettablePowerParameters.containsKey(mode)) { pw.println("Unknown mode -- '" + mode + "'"); return -1; } if (!mSettablePowerParameters.get(mode).containsKey(name)) { pw.println("Unknown parameter name -- '" + name + "' in mode '" + mode + "'"); return -1; } parentShell.getOutPrintWriter().println( (int) mSettablePowerParameters.get(mode).get(name)); return 0; } default: pw.println("Unknown 'wifiaware native_api '"); } return -1; } @Override public void onReset() { Map defaultMap = new HashMap<>(); defaultMap.put(PARAM_DW_24GHZ, PARAM_DW_24GHZ_DEFAULT); defaultMap.put(PARAM_DW_5GHZ, PARAM_DW_5GHZ_DEFAULT); defaultMap.put(PARAM_DW_6GHZ, PARAM_DW_6GHZ_DEFAULT); defaultMap.put(PARAM_DISCOVERY_BEACON_INTERVAL_MS, PARAM_DISCOVERY_BEACON_INTERVAL_MS_DEFAULT); defaultMap.put(PARAM_NUM_SS_IN_DISCOVERY, PARAM_NUM_SS_IN_DISCOVERY_DEFAULT); defaultMap.put(PARAM_ENABLE_DW_EARLY_TERM, PARAM_ENABLE_DW_EARLY_TERM_DEFAULT); Map inactiveMap = new HashMap<>(); inactiveMap.put(PARAM_DW_24GHZ, PARAM_DW_24GHZ_INACTIVE); inactiveMap.put(PARAM_DW_5GHZ, PARAM_DW_5GHZ_INACTIVE); inactiveMap.put(PARAM_DW_6GHZ, PARAM_DW_6GHZ_INACTIVE); inactiveMap.put(PARAM_DISCOVERY_BEACON_INTERVAL_MS, PARAM_DISCOVERY_BEACON_INTERVAL_MS_INACTIVE); inactiveMap.put(PARAM_NUM_SS_IN_DISCOVERY, PARAM_NUM_SS_IN_DISCOVERY_INACTIVE); inactiveMap.put(PARAM_ENABLE_DW_EARLY_TERM, PARAM_ENABLE_DW_EARLY_TERM_INACTIVE); Map idleMap = new HashMap<>(); idleMap.put(PARAM_DW_24GHZ, PARAM_DW_24GHZ_IDLE); idleMap.put(PARAM_DW_5GHZ, PARAM_DW_5GHZ_IDLE); idleMap.put(PARAM_DW_6GHZ, PARAM_DW_6GHZ_IDLE); idleMap.put(PARAM_DISCOVERY_BEACON_INTERVAL_MS, PARAM_DISCOVERY_BEACON_INTERVAL_MS_IDLE); idleMap.put(PARAM_NUM_SS_IN_DISCOVERY, PARAM_NUM_SS_IN_DISCOVERY_IDLE); idleMap.put(PARAM_ENABLE_DW_EARLY_TERM, PARAM_ENABLE_DW_EARLY_TERM_IDLE); mSettablePowerParameters.put(POWER_PARAM_DEFAULT_KEY, defaultMap); mSettablePowerParameters.put(POWER_PARAM_INACTIVE_KEY, inactiveMap); mSettablePowerParameters.put(POWER_PARAM_IDLE_KEY, idleMap); mSettableParameters.put(PARAM_MAC_RANDOM_INTERVAL_SEC, PARAM_MAC_RANDOM_INTERVAL_SEC_DEFAULT); mExternalSetParams.clear(); } @Override public void onHelp(String command, BasicShellCommandHandler parentShell) { final PrintWriter pw = parentShell.getOutPrintWriter(); pw.println(" " + command); pw.println(" set : sets named parameter to value. Names: " + mSettableParameters.keySet()); pw.println(" set-power : sets named power parameter to value." + " Modes: " + mSettablePowerParameters.keySet() + ", Names: " + mSettablePowerParameters.get(POWER_PARAM_DEFAULT_KEY).keySet()); pw.println(" get : gets named parameter value. Names: " + mSettableParameters.keySet()); pw.println(" get-power : gets named parameter value." + " Modes: " + mSettablePowerParameters.keySet() + ", Names: " + mSettablePowerParameters.get(POWER_PARAM_DEFAULT_KEY).keySet()); } /** * Query the firmware's capabilities. * * @param transactionId Transaction ID for the transaction - used in the async callback to * match with the original request. */ public boolean getCapabilities(short transactionId) { if (mVerboseLoggingEnabled) Log.v(TAG, "getCapabilities: transactionId=" + transactionId); recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "getCapabilities: null interface"); return false; } return iface.getCapabilities(transactionId); } /** * Enable and configure Aware. * @param transactionId Transaction ID for the transaction - used in the * async callback to match with the original request. * @param configRequest Requested Aware configuration. * @param notifyIdentityChange Indicates whether or not to get address change callbacks. * @param initialConfiguration Specifies whether initial configuration * (true) or an update (false) to the configuration. * @param isInteractive PowerManager.isInteractive * @param isIdle PowerManager.isIdle * @param rangingEnabled Indicates whether or not enable ranging. * @param isInstantCommunicationEnabled Indicates whether or not enable instant communication * @param instantModeChannel * @param clusterId the id of the cluster to join. */ public boolean enableAndConfigure(short transactionId, ConfigRequest configRequest, boolean notifyIdentityChange, boolean initialConfiguration, boolean isInteractive, boolean isIdle, boolean rangingEnabled, boolean isInstantCommunicationEnabled, int instantModeChannel, int clusterId) { Log.d(TAG, "enableAndConfigure: transactionId=" + transactionId + ", configRequest=" + configRequest + ", notifyIdentityChange=" + notifyIdentityChange + ", initialConfiguration=" + initialConfiguration + ", isInteractive=" + isInteractive + ", isIdle=" + isIdle + ", isRangingEnabled=" + rangingEnabled + ", isInstantCommunicationEnabled=" + isInstantCommunicationEnabled + ", instantModeChannel=" + instantModeChannel + ", clusterId=" + clusterId); recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "enableAndConfigure: null interface"); return false; } return iface.enableAndConfigure(transactionId, configRequest, notifyIdentityChange, initialConfiguration, rangingEnabled, isInstantCommunicationEnabled, instantModeChannel, clusterId, mExternalSetParams.getOrDefault(PARAM_MAC_RANDOM_INTERVAL_SEC, mSettableParameters.get(PARAM_MAC_RANDOM_INTERVAL_SEC)), getPowerParameters(isInteractive, isIdle)); } /** * Disable Aware. * * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. */ public boolean disable(short transactionId) { if (mVerboseLoggingEnabled) Log.d(TAG, "disable"); recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "disable: null interface"); return false; } boolean result = iface.disable(transactionId); return result; } /** * Start or modify a service publish session. * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. * @param publishId ID of the requested session - 0 to request a new publish * session. * @param publishConfig Configuration of the discovery session. * @param nik */ public boolean publish(short transactionId, byte publishId, PublishConfig publishConfig, byte[] nik) { if (mVerboseLoggingEnabled) { Log.d(TAG, "publish: transactionId=" + transactionId + ", publishId=" + publishId + ", config=" + publishConfig); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "publish: null interface"); return false; } return iface.publish(transactionId, publishId, publishConfig, nik); } /** * Start or modify a service subscription session. * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. * @param subscribeId ID of the requested session - 0 to request a new * subscribe session. * @param subscribeConfig Configuration of the discovery session. * @param nik */ public boolean subscribe(short transactionId, byte subscribeId, SubscribeConfig subscribeConfig, byte[] nik) { if (mVerboseLoggingEnabled) { Log.d(TAG, "subscribe: transactionId=" + transactionId + ", subscribeId=" + subscribeId + ", config=" + subscribeConfig); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "subscribe: null interface"); return false; } return iface.subscribe(transactionId, subscribeId, subscribeConfig, nik); } /** * Send a message through an existing discovery session. * * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. * @param pubSubId ID of the existing publish/subscribe session. * @param requestorInstanceId ID of the peer to communicate with - obtained * through a previous discovery (match) operation with that peer. * @param dest MAC address of the peer to communicate with - obtained * together with requestorInstanceId. * @param message Message. * @param messageId Arbitary integer from host (not sent to HAL - useful for * testing/debugging at this level) */ public boolean sendMessage(short transactionId, byte pubSubId, int requestorInstanceId, byte[] dest, byte[] message, int messageId) { if (mVerboseLoggingEnabled) { Log.d(TAG, "sendMessage: transactionId=" + transactionId + ", pubSubId=" + pubSubId + ", requestorInstanceId=" + requestorInstanceId + ", dest=" + String.valueOf(HexEncoding.encode(dest)) + ", messageId=" + messageId + ", message=" + (message == null ? "" : HexEncoding.encode(message)) + ", message.length=" + (message == null ? 0 : message.length)); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "sendMessage: null interface"); return false; } try { MacAddress destMac = MacAddress.fromBytes(dest); return iface.sendMessage( transactionId, pubSubId, requestorInstanceId, destMac, message); } catch (IllegalArgumentException e) { Log.e(TAG, "Invalid dest mac received: " + Arrays.toString(dest)); return false; } } /** * Terminate a publish discovery session. * * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. * @param pubSubId ID of the publish/subscribe session - obtained when * creating a session. */ public boolean stopPublish(short transactionId, byte pubSubId) { if (mVerboseLoggingEnabled) { Log.d(TAG, "stopPublish: transactionId=" + transactionId + ", pubSubId=" + pubSubId); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "stopPublish: null interface"); return false; } return iface.stopPublish(transactionId, pubSubId); } /** * Terminate a subscribe discovery session. * * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. * @param pubSubId ID of the publish/subscribe session - obtained when * creating a session. */ public boolean stopSubscribe(short transactionId, byte pubSubId) { if (mVerboseLoggingEnabled) { Log.d(TAG, "stopSubscribe: transactionId=" + transactionId + ", pubSubId=" + pubSubId); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "stopSubscribe: null interface"); return false; } return iface.stopSubscribe(transactionId, pubSubId); } /** * Create a Aware network interface. This only creates the Linux interface - it doesn't actually * create the data connection. * * @param transactionId Transaction ID for the transaction - used in the async callback to * match with the original request. * @param interfaceName The name of the interface, e.g. "aware0". */ public boolean createAwareNetworkInterface(short transactionId, String interfaceName) { Log.d(TAG, "createAwareNetworkInterface: transactionId=" + transactionId + ", " + "interfaceName=" + interfaceName); recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "createAwareNetworkInterface: null interface"); return false; } return iface.createAwareNetworkInterface(transactionId, interfaceName); } /** * Deletes a Aware network interface. The data connection can (should?) be torn down previously. * * @param transactionId Transaction ID for the transaction - used in the async callback to * match with the original request. * @param interfaceName The name of the interface, e.g. "aware0". */ public boolean deleteAwareNetworkInterface(short transactionId, String interfaceName) { Log.d(TAG, "deleteAwareNetworkInterface: transactionId=" + transactionId + ", " + "interfaceName=" + interfaceName); recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "deleteAwareNetworkInterface: null interface"); return false; } return iface.deleteAwareNetworkInterface(transactionId, interfaceName); } /** * Initiates setting up a data-path between device and peer. Security is provided by either * PMK or Passphrase (not both) - if both are null then an open (unencrypted) link is set up. * * @param transactionId Transaction ID for the transaction - used in the async callback to * match with the original request. * @param peerId ID of the peer ID to associate the data path with. A value of 0 * indicates that not associated with an existing session. * @param channelRequestType Indicates whether the specified channel is available, if available * requested or forced (resulting in failure if cannot be * accommodated). * @param channel The channel on which to set up the data-path. * @param peer The MAC address of the peer to create a connection with. * @param interfaceName The interface on which to create the data connection. * @param isOutOfBand Is the data-path out-of-band (i.e. without a corresponding Aware * discovery * session). * @param appInfo Arbitrary binary blob transmitted to the peer. * @param capabilities The capabilities of the firmware. * @param securityConfig Security config to encrypt the data-path */ public boolean initiateDataPath(short transactionId, int peerId, int channelRequestType, int channel, byte[] peer, String interfaceName, boolean isOutOfBand, byte[] appInfo, Capabilities capabilities, WifiAwareDataPathSecurityConfig securityConfig, byte pubSubId) { if (mVerboseLoggingEnabled) { Log.v(TAG, "initiateDataPath: transactionId=" + transactionId + ", peerId=" + peerId + ", channelRequestType=" + channelRequestType + ", channel=" + channel + ", peer=" + String.valueOf(HexEncoding.encode(peer)) + ", interfaceName=" + interfaceName + ", securityConfig=" + securityConfig + ", isOutOfBand=" + isOutOfBand + ", appInfo.length=" + ((appInfo == null) ? 0 : appInfo.length) + ", capabilities=" + capabilities); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "initiateDataPath: null interface"); return false; } try { MacAddress peerMac = MacAddress.fromBytes(peer); return iface.initiateDataPath(transactionId, peerId, channelRequestType, channel, peerMac, interfaceName, isOutOfBand, appInfo, capabilities, securityConfig, pubSubId); } catch (IllegalArgumentException e) { Log.e(TAG, "Invalid peer mac received: " + Arrays.toString(peer)); return false; } } /** * Responds to a data request from a peer. Security is provided by either PMK or Passphrase (not * both) - if both are null then an open (unencrypted) link is set up. * * @param transactionId Transaction ID for the transaction - used in the async callback to * match with the original request. * @param accept Accept (true) or reject (false) the original call. * @param ndpId The NDP (Aware data path) ID. Obtained from the request callback. * @param interfaceName The interface on which the data path will be setup. Obtained from the * request callback. * @param appInfo Arbitrary binary blob transmitted to the peer. * @param isOutOfBand Is the data-path out-of-band (i.e. without a corresponding Aware * discovery * session). * @param capabilities The capabilities of the firmware. * @param securityConfig Security config to encrypt the data-path */ public boolean respondToDataPathRequest(short transactionId, boolean accept, int ndpId, String interfaceName, byte[] appInfo, boolean isOutOfBand, Capabilities capabilities, WifiAwareDataPathSecurityConfig securityConfig, byte pubSubId) { if (mVerboseLoggingEnabled) { Log.v(TAG, "respondToDataPathRequest: transactionId=" + transactionId + ", accept=" + accept + ", int ndpId=" + ndpId + ", interfaceName=" + interfaceName + ", appInfo.length=" + ((appInfo == null) ? 0 : appInfo.length) + ", securityConfig" + securityConfig); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "respondToDataPathRequest: null interface"); return false; } return iface.respondToDataPathRequest(transactionId, accept, ndpId, interfaceName, appInfo, isOutOfBand, capabilities, securityConfig, pubSubId); } /** * Terminate an existing data-path (does not delete the interface). * * @param transactionId Transaction ID for the transaction - used in the async callback to * match with the original request. * @param ndpId The NDP (Aware data path) ID to be terminated. */ public boolean endDataPath(short transactionId, int ndpId) { if (mVerboseLoggingEnabled) { Log.v(TAG, "endDataPath: transactionId=" + transactionId + ", ndpId=" + ndpId); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "endDataPath: null interface"); return false; } return iface.endDataPath(transactionId, ndpId); } /** * Terminate an existing pairing setup * * @param transactionId Transaction ID for the transaction - used in the async callback to * match with the original request. * @param pairId The id of the pairing session */ public boolean endPairing(short transactionId, int pairId) { if (mVerboseLoggingEnabled) { Log.v(TAG, "endPairing: transactionId=" + transactionId + ", ndpId=" + pairId); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "endDataPath: null interface"); return false; } return iface.endPairing(transactionId, pairId); } /** * Initiate a NAN pairing request for this publish/subscribe session * * @param transactionId Transaction ID for the transaction - used in the * async callback to match with the original request. * @param peerId ID of the peer. Obtained through previous communication (a * match indication). * @param pairingIdentityKey NAN identity key * @param requestType Setup or verification * @param pmk credential for the pairing verification * @param password credential for the pairing setup * @param akm Key exchange method is used for pairing * @return True is the request send succeed. */ public boolean initiatePairing(short transactionId, int peerId, byte[] peer, byte[] pairingIdentityKey, boolean enablePairingCache, int requestType, byte[] pmk, String password, int akm, int cipherSuite) { if (mVerboseLoggingEnabled) { Log.v(TAG, "initiatePairing: transactionId=" + transactionId + ", peerId=" + peerId + ", requestType=" + requestType + ", enablePairingCache=" + enablePairingCache + ", peer=" + String.valueOf(HexEncoding.encode(peer))); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "initiatePairing: null interface"); return false; } try { MacAddress peerMac = MacAddress.fromBytes(peer); return iface.initiatePairing(transactionId, peerId, peerMac, pairingIdentityKey, enablePairingCache, requestType, pmk, password, akm, cipherSuite); } catch (IllegalArgumentException e) { Log.e(TAG, "Invalid peer mac received: " + Arrays.toString(peer)); return false; } } /** * Response to a NAN pairing request for this from this session * * @param transactionId Transaction ID for the transaction - used in the * async callback to match with the original request. * @param pairingId The id of the current pairing session * @param accept True if accpect, false otherwise * @param pairingIdentityKey NAN identity key * @param requestType Setup or verification * @param pmk credential for the pairing verification * @param password credential for the pairing setup * @param akm Key exchange method is used for pairing * @return True is the request send succeed. */ public boolean respondToPairingRequest(short transactionId, int pairingId, boolean accept, byte[] pairingIdentityKey, boolean enablePairingCache, int requestType, byte[] pmk, String password, int akm, int cipherSuite) { if (mVerboseLoggingEnabled) { Log.v( TAG, "respondToPairingRequest: transactionId=" + transactionId + ", accept=" + accept + ", int pairingId=" + pairingId + ", enablePairingCache=" + enablePairingCache + ", requestType" + requestType); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "respondToPairingRequest: null interface"); return false; } return iface.respondToPairingRequest(transactionId, pairingId, accept, pairingIdentityKey, enablePairingCache, requestType, pmk, password, akm, cipherSuite); } /** * Initiate a Bootstrapping request for this publish/subscribe session * * @param transactionId Transaction ID for the transaction - used in the * async callback to match with the original request. * @param peerId ID of the peer. Obtained through previous communication (a match * indication). * @param peer The MAC address of the peer to create a connection with. * @param method proposed bootstrapping method * @param pubSubId ID of the publish/subscribe session - obtained when creating a session. * @param isComeBack If the request is for a previous comeback response * @return True if the request send success */ public boolean initiateBootstrapping(short transactionId, int peerId, byte[] peer, int method, byte[] cookie, byte pubSubId, boolean isComeBack) { if (mVerboseLoggingEnabled) { Log.v(TAG, "initiateBootstrapping: transactionId=" + transactionId + ", peerId=" + peerId + ", method=" + method + ", peer=" + String.valueOf(HexEncoding.encode(peer))); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "initiateBootstrapping: null interface"); return false; } try { MacAddress peerMac = MacAddress.fromBytes(peer); return iface.initiateBootstrapping(transactionId, peerId, peerMac, method, cookie, pubSubId, isComeBack); } catch (IllegalArgumentException e) { Log.e(TAG, "Invalid peer mac received: " + Arrays.toString(peer)); return false; } } /** * Response to a bootstrapping request for this from this session * * @param transactionId Transaction ID for the transaction - used in the * async callback to match with the original request. * @param bootstrappingId The id of the current boostraping session * @param accept True is proposed method is accepte * @param pubSubId ID of the publish/subscribe session - obtained when creating a * session. * @return True if the request send success */ public boolean respondToBootstrappingRequest(short transactionId, int bootstrappingId, boolean accept, byte pubSubId) { if (mVerboseLoggingEnabled) { Log.v(TAG, "respondToBootstrappingRequest: transactionId=" + transactionId); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "respondToBootstrappingRequest: null interface"); return false; } return iface.respondToBootstrappingRequest(transactionId, bootstrappingId, accept, pubSubId); } /** * Suspends the specified Aware session. * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. * @param pubSubId ID of the existing publish/subscribe session. * @return True if the request is sent successfully. */ public boolean suspendRequest(short transactionId, byte pubSubId) { if (mVerboseLoggingEnabled) { Log.v(TAG, "suspendRequest: transactionId=" + transactionId); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "suspendRequest: null interface"); return false; } return iface.suspendRequest(transactionId, pubSubId); } /** * Resumes the specified (suspended) Aware session. * @param transactionId transactionId Transaction ID for the transaction - * used in the async callback to match with the original request. * @param pubSubId ID of the existing publish/subscribe session. * @return True if the request is sent successfully. */ public boolean resumeRequest(short transactionId, byte pubSubId) { if (mVerboseLoggingEnabled) { Log.v(TAG, "resumeRequest: transactionId=" + transactionId); } recordTransactionId(transactionId); WifiNanIface iface = mHal.getWifiNanIface(); if (iface == null) { Log.e(TAG, "resumeRequest: null interface"); return false; } return iface.resumeRequest(transactionId, pubSubId); } // utilities /** * Create a PowerParameters object to pass our cached parameters to the HAL. */ private PowerParameters getPowerParameters( boolean isInteractive, boolean isIdle) { PowerParameters params = new PowerParameters(); String key = POWER_PARAM_DEFAULT_KEY; if (isIdle) { key = POWER_PARAM_IDLE_KEY; } else if (!isInteractive) { key = POWER_PARAM_INACTIVE_KEY; } params.discoveryWindow24Ghz = getSettablePowerParameters(key, PARAM_DW_24GHZ); params.discoveryWindow5Ghz = getSettablePowerParameters(key, PARAM_DW_5GHZ); params.discoveryWindow6Ghz = getSettablePowerParameters(key, PARAM_DW_6GHZ); params.discoveryBeaconIntervalMs = getSettablePowerParameters(key, PARAM_DISCOVERY_BEACON_INTERVAL_MS); params.numberOfSpatialStreamsInDiscovery = getSettablePowerParameters(key, PARAM_NUM_SS_IN_DISCOVERY); params.enableDiscoveryWindowEarlyTermination = getSettablePowerParameters(key, PARAM_ENABLE_DW_EARLY_TERM) != 0; return params; } private int getSettablePowerParameters(String state, String key) { if (mExternalSetParams.containsKey(key)) { return mExternalSetParams.get(key); } return mSettablePowerParameters.get(state).get(key); } /** * Dump the internal state of the class. */ public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { pw.println("WifiAwareNativeApi:"); pw.println(" mSettableParameters: " + mSettableParameters); pw.println(" mExternalSetParams" + mExternalSetParams); mHal.dump(fd, pw, args); } }