Add 11az secure ranging hal implementation
Bug: 364722301
Test: Test: atest com.android.server.wifi
Flag: com.android.wifi.flags.secure_ranging
Change-Id: I14add28688514f7fe1baf10c5570b6909a74f38c
diff --git a/wifi/aidl/default/aidl_struct_util.cpp b/wifi/aidl/default/aidl_struct_util.cpp
index a404853..6bd5a7f 100644
--- a/wifi/aidl/default/aidl_struct_util.cpp
+++ b/wifi/aidl/default/aidl_struct_util.cpp
@@ -2815,6 +2815,138 @@
return true;
}
+long convertLegacyAkmsToAidl(legacy_hal::wifi_rtt_akm akms) {
+ long aidl_akms = Akm::NONE;
+ if ((akms & legacy_hal::WPA_KEY_MGMT_PASN) != 0) {
+ aidl_akms |= Akm::PASN;
+ }
+ if ((akms & legacy_hal::WPA_KEY_MGMT_SAE) != 0) {
+ aidl_akms |= Akm::SAE;
+ }
+ if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA256) != 0) {
+ aidl_akms |= Akm::FT_EAP_SHA256;
+ }
+ if ((akms & legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA256) != 0) {
+ aidl_akms |= Akm::FT_PSK_SHA256;
+ }
+ if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA384) != 0) {
+ aidl_akms |= Akm::FT_EAP_SHA384;
+ }
+ if ((akms & legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA384) != 0) {
+ aidl_akms |= Akm::FT_PSK_SHA384;
+ }
+ if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA256) != 0) {
+ aidl_akms |= Akm::FILS_EAP_SHA256;
+ }
+ if ((akms & legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA384) != 0) {
+ aidl_akms |= Akm::FILS_EAP_SHA384;
+ }
+ return aidl_akms;
+}
+
+legacy_hal::wifi_rtt_akm convertAidlAkmToLegacy(long akm) {
+ switch (akm) {
+ case Akm::PASN:
+ return legacy_hal::WPA_KEY_MGMT_PASN;
+ case Akm::SAE:
+ return legacy_hal::WPA_KEY_MGMT_SAE;
+ case Akm::FT_EAP_SHA256:
+ return legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA256;
+ case Akm::FT_PSK_SHA256:
+ return legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA256;
+ case Akm::FT_EAP_SHA384:
+ return legacy_hal::WPA_KEY_MGMT_EAP_FT_SHA384;
+ case Akm::FT_PSK_SHA384:
+ return legacy_hal::WPA_KEY_MGMT_FT_PSK_SHA384;
+ case Akm::FILS_EAP_SHA256:
+ return legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA256;
+ case Akm::FILS_EAP_SHA384:
+ return legacy_hal::WPA_KEY_MGMT_EAP_FILS_SHA384;
+ default:
+ return legacy_hal::WPA_KEY_MGMT_NONE;
+ }
+}
+
+long convertLegacyCipherSuitesToAidl(legacy_hal::wifi_rtt_cipher_suite ciphers) {
+ long aidl_ciphers = CipherSuite::NONE;
+ if ((ciphers & legacy_hal::WPA_CIPHER_CCMP_128) != 0) {
+ aidl_ciphers |= CipherSuite::CCMP_128;
+ }
+ if ((ciphers & legacy_hal::WPA_CIPHER_CCMP_256) != 0) {
+ aidl_ciphers |= CipherSuite::CCMP_256;
+ }
+ if ((ciphers & legacy_hal::WPA_CIPHER_GCMP_128) != 0) {
+ aidl_ciphers |= CipherSuite::GCMP_128;
+ }
+ if ((ciphers & legacy_hal::WPA_CIPHER_GCMP_256) != 0) {
+ aidl_ciphers |= CipherSuite::GCMP_256;
+ }
+ return aidl_ciphers;
+}
+
+legacy_hal::wifi_rtt_cipher_suite convertAidlCipherSuiteToLegacy(long cipher) {
+ switch (cipher) {
+ case CipherSuite::CCMP_128:
+ return WPA_CIPHER_CCMP_128;
+ case CipherSuite::CCMP_256:
+ return WPA_CIPHER_CCMP_256;
+ case CipherSuite::GCMP_128:
+ return WPA_CIPHER_GCMP_128;
+ case CipherSuite::GCMP_256:
+ return WPA_CIPHER_GCMP_256;
+ default:
+ return WPA_CIPHER_NONE;
+ }
+}
+
+bool convertAidlRttConfigToLegacyV4(const RttConfig& aidl_config,
+ legacy_hal::wifi_rtt_config_v4* legacy_config) {
+ if (!legacy_config) {
+ return false;
+ }
+ *legacy_config = {};
+ if (!convertAidlRttConfigToLegacyV3(aidl_config, &(legacy_config->rtt_config))) {
+ return false;
+ }
+ if (aidl_config.secureConfig.has_value()) {
+ legacy_config->rtt_secure_config.enable_secure_he_ltf =
+ aidl_config.secureConfig->enableSecureHeLtf;
+ legacy_config->rtt_secure_config.enable_ranging_frame_protection =
+ aidl_config.secureConfig->enableRangingFrameProtection;
+ if (aidl_config.secureConfig->pasnComebackCookie.has_value() &&
+ aidl_config.secureConfig->pasnComebackCookie->size() <= RTT_MAX_COOKIE_LEN) {
+ legacy_config->rtt_secure_config.pasn_config.comeback_cookie_len =
+ aidl_config.secureConfig->pasnComebackCookie->size();
+ memcpy(legacy_config->rtt_secure_config.pasn_config.comeback_cookie,
+ aidl_config.secureConfig->pasnComebackCookie->data(),
+ aidl_config.secureConfig->pasnComebackCookie->size());
+ }
+ legacy_config->rtt_secure_config.pasn_config.base_akm =
+ convertAidlAkmToLegacy(aidl_config.secureConfig->pasnConfig.baseAkm);
+ legacy_config->rtt_secure_config.pasn_config.pairwise_cipher_suite =
+ convertAidlCipherSuiteToLegacy(aidl_config.secureConfig->pasnConfig.cipherSuite);
+ if (aidl_config.secureConfig->pasnConfig.passphrase.has_value() &&
+ aidl_config.secureConfig->pasnConfig.passphrase->size() <=
+ RTT_SECURITY_MAX_PASSPHRASE_LEN) {
+ legacy_config->rtt_secure_config.pasn_config.passphrase_len =
+ aidl_config.secureConfig->pasnConfig.passphrase->size();
+ memcpy(legacy_config->rtt_secure_config.pasn_config.passphrase,
+ aidl_config.secureConfig->pasnConfig.passphrase->data(),
+ aidl_config.secureConfig->pasnConfig.passphrase->size());
+ }
+ if (aidl_config.secureConfig->pasnConfig.pmkid.has_value() &&
+ aidl_config.secureConfig->pasnConfig.pmkid->size() == PMKID_LEN) {
+ legacy_config->rtt_secure_config.pasn_config.pmkid_len =
+ aidl_config.secureConfig->pasnConfig.pmkid->size();
+ memcpy(legacy_config->rtt_secure_config.pasn_config.pmkid,
+ aidl_config.secureConfig->pasnConfig.pmkid->data(),
+ aidl_config.secureConfig->pasnConfig.pmkid->size());
+ }
+ }
+
+ return true;
+}
+
bool convertAidlVectorOfRttConfigToLegacy(
const std::vector<RttConfig>& aidl_configs,
std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {
@@ -2849,6 +2981,23 @@
return true;
}
+bool convertAidlVectorOfRttConfigToLegacyV4(
+ const std::vector<RttConfig>& aidl_configs,
+ std::vector<legacy_hal::wifi_rtt_config_v4>* legacy_configs) {
+ if (!legacy_configs) {
+ return false;
+ }
+ *legacy_configs = {};
+ for (const auto& aidl_config : aidl_configs) {
+ legacy_hal::wifi_rtt_config_v4 legacy_config;
+ if (!convertAidlRttConfigToLegacyV4(aidl_config, &legacy_config)) {
+ return false;
+ }
+ legacy_configs->push_back(legacy_config);
+ }
+ return true;
+}
+
bool convertAidlRttLciInformationToLegacy(const RttLciInformation& aidl_info,
legacy_hal::wifi_lci_information* legacy_info) {
if (!legacy_info) {
@@ -2959,6 +3108,12 @@
aidl_capabilities->azBwSupport = (int)RttBw::BW_UNSPECIFIED;
aidl_capabilities->ntbInitiatorSupported = false;
aidl_capabilities->ntbResponderSupported = false;
+ // Initialize 11az secure ranging parameters to default
+ aidl_capabilities->akmsSupported = Akm::NONE;
+ aidl_capabilities->cipherSuitesSupported = CipherSuite::NONE;
+ aidl_capabilities->secureHeLtfSupported = false;
+ aidl_capabilities->rangingFrameProtectionSupported = false;
+ aidl_capabilities->maxSupportedSecureHeLtfProtocolVersion = false;
return true;
}
@@ -2986,6 +3141,53 @@
(int)convertLegacyRttBwBitmapToAidl(legacy_capabilities_v3.az_bw_support);
aidl_capabilities->ntbInitiatorSupported = legacy_capabilities_v3.ntb_initiator_supported;
aidl_capabilities->ntbResponderSupported = legacy_capabilities_v3.ntb_responder_supported;
+ // Initialize 11az secure ranging parameters to default
+ aidl_capabilities->akmsSupported = Akm::NONE;
+ aidl_capabilities->cipherSuitesSupported = CipherSuite::NONE;
+ aidl_capabilities->secureHeLtfSupported = false;
+ aidl_capabilities->rangingFrameProtectionSupported = false;
+ aidl_capabilities->maxSupportedSecureHeLtfProtocolVersion = false;
+
+ return true;
+}
+
+bool convertLegacyRttCapabilitiesV4ToAidl(
+ const legacy_hal::wifi_rtt_capabilities_v4& legacy_capabilities_v4,
+ RttCapabilities* aidl_capabilities) {
+ if (!aidl_capabilities) {
+ return false;
+ }
+ *aidl_capabilities = {};
+ aidl_capabilities->rttOneSidedSupported =
+ legacy_capabilities_v4.rtt_capab_v3.rtt_capab.rtt_one_sided_supported;
+ aidl_capabilities->rttFtmSupported =
+ legacy_capabilities_v4.rtt_capab_v3.rtt_capab.rtt_ftm_supported;
+ aidl_capabilities->lciSupported = legacy_capabilities_v4.rtt_capab_v3.rtt_capab.lci_support;
+ aidl_capabilities->lcrSupported = legacy_capabilities_v4.rtt_capab_v3.rtt_capab.lcr_support;
+ aidl_capabilities->responderSupported =
+ legacy_capabilities_v4.rtt_capab_v3.rtt_capab.responder_supported;
+ aidl_capabilities->preambleSupport = convertLegacyRttPreambleBitmapToAidl(
+ legacy_capabilities_v4.rtt_capab_v3.rtt_capab.preamble_support);
+ aidl_capabilities->bwSupport = convertLegacyRttBwBitmapToAidl(
+ legacy_capabilities_v4.rtt_capab_v3.rtt_capab.bw_support);
+ aidl_capabilities->mcVersion = legacy_capabilities_v4.rtt_capab_v3.rtt_capab.mc_version;
+ aidl_capabilities->azPreambleSupport = (int)convertLegacyRttPreambleBitmapToAidl(
+ legacy_capabilities_v4.rtt_capab_v3.az_preamble_support);
+ aidl_capabilities->azBwSupport =
+ (int)convertLegacyRttBwBitmapToAidl(legacy_capabilities_v4.rtt_capab_v3.az_bw_support);
+ aidl_capabilities->ntbInitiatorSupported =
+ legacy_capabilities_v4.rtt_capab_v3.ntb_initiator_supported;
+ aidl_capabilities->ntbResponderSupported =
+ legacy_capabilities_v4.rtt_capab_v3.ntb_responder_supported;
+ aidl_capabilities->akmsSupported =
+ convertLegacyAkmsToAidl(legacy_capabilities_v4.supported_akms);
+ aidl_capabilities->cipherSuitesSupported =
+ convertLegacyCipherSuitesToAidl(legacy_capabilities_v4.supported_cipher_suites);
+ aidl_capabilities->secureHeLtfSupported = legacy_capabilities_v4.secure_he_ltf_supported;
+ aidl_capabilities->rangingFrameProtectionSupported =
+ legacy_capabilities_v4.ranging_fame_protection_supported;
+ aidl_capabilities->maxSupportedSecureHeLtfProtocolVersion =
+ legacy_capabilities_v4.max_supported_secure_he_ltf_protocol_ver;
return true;
}
@@ -3066,6 +3268,13 @@
aidl_result.ntbMaxMeasurementTime = 0;
aidl_result.numTxSpatialStreams = 0;
aidl_result.numRxSpatialStreams = 0;
+ aidl_result.isRangingFrameProtectionEnabled = false;
+ aidl_result.isSecureLtfEnabled = false;
+ aidl_result.baseAkm = Akm::NONE;
+ aidl_result.cipherSuite = CipherSuite::NONE;
+ aidl_result.secureHeLtfProtocolVersion = 0;
+ aidl_result.pasnComebackAfterMillis = 0;
+ aidl_result.pasnComebackCookie = std::nullopt;
aidl_results->push_back(aidl_result);
}
return true;
@@ -3092,6 +3301,13 @@
aidl_result.ntbMaxMeasurementTime = 0;
aidl_result.numTxSpatialStreams = 0;
aidl_result.numRxSpatialStreams = 0;
+ aidl_result.isRangingFrameProtectionEnabled = false;
+ aidl_result.isSecureLtfEnabled = false;
+ aidl_result.baseAkm = Akm::NONE;
+ aidl_result.cipherSuite = CipherSuite::NONE;
+ aidl_result.secureHeLtfProtocolVersion = 0;
+ aidl_result.pasnComebackAfterMillis = 0;
+ aidl_result.pasnComebackCookie = std::nullopt;
aidl_results->push_back(aidl_result);
}
return true;
@@ -3119,6 +3335,57 @@
aidl_result.ntbMaxMeasurementTime = legacy_result->ntb_max_measurement_time;
aidl_result.numTxSpatialStreams = legacy_result->num_tx_sts;
aidl_result.numRxSpatialStreams = legacy_result->num_rx_sts;
+ aidl_result.isRangingFrameProtectionEnabled = false;
+ aidl_result.isSecureLtfEnabled = false;
+ aidl_result.baseAkm = Akm::NONE;
+ aidl_result.cipherSuite = CipherSuite::NONE;
+ aidl_result.secureHeLtfProtocolVersion = 0;
+ aidl_result.pasnComebackAfterMillis = 0;
+ aidl_result.pasnComebackCookie = std::nullopt;
+ aidl_results->push_back(aidl_result);
+ }
+ return true;
+}
+
+bool convertLegacyVectorOfRttResultV4ToAidl(
+ const std::vector<const legacy_hal::wifi_rtt_result_v4*>& legacy_results,
+ std::vector<RttResult>* aidl_results) {
+ if (!aidl_results) {
+ return false;
+ }
+ *aidl_results = {};
+ for (const auto legacy_result : legacy_results) {
+ RttResult aidl_result;
+ if (!convertLegacyRttResultToAidl(legacy_result->rtt_result_v3.rtt_result.rtt_result,
+ &aidl_result)) {
+ return false;
+ }
+ aidl_result.channelFreqMHz =
+ legacy_result->rtt_result_v3.rtt_result.frequency != UNSPECIFIED
+ ? legacy_result->rtt_result_v3.rtt_result.frequency
+ : 0;
+ aidl_result.packetBw =
+ convertLegacyRttBwToAidl(legacy_result->rtt_result_v3.rtt_result.packet_bw);
+ aidl_result.i2rTxLtfRepetitionCount =
+ legacy_result->rtt_result_v3.i2r_tx_ltf_repetition_count;
+ aidl_result.r2iTxLtfRepetitionCount =
+ legacy_result->rtt_result_v3.r2i_tx_ltf_repetition_count;
+ aidl_result.ntbMinMeasurementTime = legacy_result->rtt_result_v3.ntb_min_measurement_time;
+ aidl_result.ntbMaxMeasurementTime = legacy_result->rtt_result_v3.ntb_max_measurement_time;
+ aidl_result.numTxSpatialStreams = legacy_result->rtt_result_v3.num_tx_sts;
+ aidl_result.numRxSpatialStreams = legacy_result->rtt_result_v3.num_rx_sts;
+ aidl_result.isRangingFrameProtectionEnabled = legacy_result->is_ranging_protection_enabled;
+ aidl_result.isSecureLtfEnabled = legacy_result->is_secure_he_ltf_enabled;
+ aidl_result.baseAkm = convertLegacyAkmsToAidl(legacy_result->base_akm);
+ aidl_result.cipherSuite = convertLegacyCipherSuitesToAidl(legacy_result->cipher_suite);
+ aidl_result.secureHeLtfProtocolVersion = legacy_result->secure_he_ltf_protocol_version;
+ aidl_result.pasnComebackAfterMillis = legacy_result->pasn_comeback_after_millis;
+ if (legacy_result->pasn_comeback_cookie_len > 0 &&
+ legacy_result->pasn_comeback_cookie_len <= RTT_MAX_COOKIE_LEN) {
+ aidl_result.pasnComebackCookie = std::vector<uint8_t>(
+ legacy_result->pasn_comeback_cookie,
+ legacy_result->pasn_comeback_cookie + legacy_result->pasn_comeback_cookie_len);
+ }
aidl_results->push_back(aidl_result);
}
return true;
diff --git a/wifi/aidl/default/aidl_struct_util.h b/wifi/aidl/default/aidl_struct_util.h
index 9a3c535..b6a06db 100644
--- a/wifi/aidl/default/aidl_struct_util.h
+++ b/wifi/aidl/default/aidl_struct_util.h
@@ -17,6 +17,8 @@
#ifndef AIDL_STRUCT_UTIL_H_
#define AIDL_STRUCT_UTIL_H_
+#include <aidl/android/hardware/wifi/Akm.h>
+#include <aidl/android/hardware/wifi/CipherSuite.h>
#include <aidl/android/hardware/wifi/IWifiChip.h>
#include <aidl/android/hardware/wifi/IWifiChipEventCallback.h>
#include <aidl/android/hardware/wifi/NanBandIndex.h>
@@ -153,6 +155,10 @@
const std::vector<RttConfig>& aidl_configs,
std::vector<legacy_hal::wifi_rtt_config_v3>* legacy_configs);
+bool convertAidlVectorOfRttConfigToLegacyV4(
+ const std::vector<RttConfig>& aidl_configs,
+ std::vector<legacy_hal::wifi_rtt_config_v4>* legacy_configs);
+
bool convertAidlRttLciInformationToLegacy(const RttLciInformation& aidl_info,
legacy_hal::wifi_lci_information* legacy_info);
bool convertAidlRttLcrInformationToLegacy(const RttLcrInformation& aidl_info,
@@ -169,6 +175,9 @@
bool convertLegacyRttCapabilitiesV3ToAidl(
const legacy_hal::wifi_rtt_capabilities_v3& legacy_capabilities_v3,
RttCapabilities* aidl_capabilities);
+bool convertLegacyRttCapabilitiesV4ToAidl(
+ const legacy_hal::wifi_rtt_capabilities_v4& legacy_capabilities_v4,
+ RttCapabilities* aidl_capabilities);
bool convertLegacyVectorOfRttResultToAidl(
const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,
@@ -179,6 +188,9 @@
bool convertLegacyVectorOfRttResultV3ToAidl(
const std::vector<const legacy_hal::wifi_rtt_result_v3*>& legacy_results,
std::vector<RttResult>* aidl_results);
+bool convertLegacyVectorOfRttResultV4ToAidl(
+ const std::vector<const legacy_hal::wifi_rtt_result_v4*>& legacy_results,
+ std::vector<RttResult>* aidl_results);
uint32_t convertAidlWifiBandToLegacyMacBand(WifiBand band);
uint32_t convertAidlWifiIfaceModeToLegacy(uint32_t aidl_iface_mask);
uint32_t convertAidlUsableChannelFilterToLegacy(uint32_t aidl_filter_mask);
diff --git a/wifi/aidl/default/wifi_legacy_hal.cpp b/wifi/aidl/default/wifi_legacy_hal.cpp
index 8d69013..c6d6177 100644
--- a/wifi/aidl/default/wifi_legacy_hal.cpp
+++ b/wifi/aidl/default/wifi_legacy_hal.cpp
@@ -185,11 +185,14 @@
on_rtt_results_internal_callback_v2;
std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result_v3* rtt_results_v3[])>
on_rtt_results_internal_callback_v3;
+std::function<void(wifi_request_id, unsigned num_results, wifi_rtt_result_v4* rtt_results_v4[])>
+ on_rtt_results_internal_callback_v4;
void invalidateRttResultsCallbacks() {
on_rtt_results_internal_callback = nullptr;
on_rtt_results_internal_callback_v2 = nullptr;
on_rtt_results_internal_callback_v3 = nullptr;
+ on_rtt_results_internal_callback_v4 = nullptr;
};
void onAsyncRttResults(wifi_request_id id, unsigned num_results, wifi_rtt_result* rtt_results[]) {
@@ -218,6 +221,15 @@
}
}
+void onAsyncRttResultsV4(wifi_request_id id, unsigned num_results,
+ wifi_rtt_result_v4* rtt_results_v4[]) {
+ const auto lock = aidl_sync_util::acquireGlobalLock();
+ if (on_rtt_results_internal_callback_v4) {
+ on_rtt_results_internal_callback_v4(id, num_results, rtt_results_v4);
+ invalidateRttResultsCallbacks();
+ }
+}
+
// Callbacks for the various NAN operations.
// NOTE: These have very little conversions to perform before invoking the user
// callbacks.
@@ -1344,6 +1356,38 @@
return status;
}
+wifi_error WifiLegacyHal::startRttRangeRequestV4(
+ const std::string& iface_name, wifi_request_id id,
+ const std::vector<wifi_rtt_config_v4>& rtt_configs,
+ const on_rtt_results_callback_v4& on_results_user_callback_v4) {
+ if (on_rtt_results_internal_callback_v4) {
+ return WIFI_ERROR_NOT_AVAILABLE;
+ }
+
+ on_rtt_results_internal_callback_v4 = [on_results_user_callback_v4](
+ wifi_request_id id, unsigned num_results,
+ wifi_rtt_result_v4* rtt_results_v4[]) {
+ if (num_results > 0 && !rtt_results_v4) {
+ LOG(ERROR) << "Unexpected nullptr in RTT v4 results";
+ return;
+ }
+ std::vector<const wifi_rtt_result_v4*> rtt_results_vec_v4;
+ std::copy_if(rtt_results_v4, rtt_results_v4 + num_results,
+ back_inserter(rtt_results_vec_v4),
+ [](wifi_rtt_result_v4* rtt_result_v4) { return rtt_result_v4 != nullptr; });
+ on_results_user_callback_v4(id, rtt_results_vec_v4);
+ };
+
+ std::vector<wifi_rtt_config_v4> rtt_configs_internal(rtt_configs);
+ wifi_error status = global_func_table_.wifi_rtt_range_request_v4(
+ id, getIfaceHandle(iface_name), rtt_configs.size(), rtt_configs_internal.data(),
+ {onAsyncRttResultsV4});
+ if (status != WIFI_SUCCESS) {
+ invalidateRttResultsCallbacks();
+ }
+ return status;
+}
+
wifi_error WifiLegacyHal::startRttRangeRequestV3(
const std::string& iface_name, wifi_request_id id,
const std::vector<wifi_rtt_config_v3>& rtt_configs,
@@ -1460,6 +1504,14 @@
return {status, rtt_caps_v3};
}
+std::pair<wifi_error, wifi_rtt_capabilities_v4> WifiLegacyHal::getRttCapabilitiesV4(
+ const std::string& iface_name) {
+ wifi_rtt_capabilities_v4 rtt_caps_v4;
+ wifi_error status = global_func_table_.wifi_get_rtt_capabilities_v4(getIfaceHandle(iface_name),
+ &rtt_caps_v4);
+ return {status, rtt_caps_v4};
+}
+
std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo(
const std::string& iface_name) {
wifi_rtt_responder rtt_responder;
diff --git a/wifi/aidl/default/wifi_legacy_hal.h b/wifi/aidl/default/wifi_legacy_hal.h
index f603210..46bf790 100644
--- a/wifi/aidl/default/wifi_legacy_hal.h
+++ b/wifi/aidl/default/wifi_legacy_hal.h
@@ -350,6 +350,7 @@
using ::wifi_ring_buffer_status;
using ::wifi_roaming_capabilities;
using ::wifi_roaming_config;
+using ::wifi_rtt_akm;
using ::wifi_rtt_bw;
using ::WIFI_RTT_BW_10;
using ::WIFI_RTT_BW_160;
@@ -361,8 +362,11 @@
using ::WIFI_RTT_BW_UNSPECIFIED;
using ::wifi_rtt_capabilities;
using ::wifi_rtt_capabilities_v3;
+using ::wifi_rtt_capabilities_v4;
+using ::wifi_rtt_cipher_suite;
using ::wifi_rtt_config;
using ::wifi_rtt_config_v3;
+using ::wifi_rtt_config_v4;
using ::wifi_rtt_preamble;
using ::WIFI_RTT_PREAMBLE_EHT;
using ::WIFI_RTT_PREAMBLE_HE;
@@ -374,6 +378,7 @@
using ::wifi_rtt_result;
using ::wifi_rtt_result_v2;
using ::wifi_rtt_result_v3;
+using ::wifi_rtt_result_v4;
using ::wifi_rtt_status;
using ::wifi_rtt_type;
using ::wifi_rx_packet_fate;
@@ -399,6 +404,20 @@
using ::WLAN_MAC_5_0_BAND;
using ::WLAN_MAC_60_0_BAND;
using ::WLAN_MAC_6_0_BAND;
+using ::WPA_CIPHER_CCMP_128;
+using ::WPA_CIPHER_CCMP_256;
+using ::WPA_CIPHER_GCMP_128;
+using ::WPA_CIPHER_GCMP_256;
+using ::WPA_CIPHER_NONE;
+using ::WPA_KEY_MGMT_EAP_FILS_SHA256;
+using ::WPA_KEY_MGMT_EAP_FILS_SHA384;
+using ::WPA_KEY_MGMT_EAP_FT_SHA256;
+using ::WPA_KEY_MGMT_EAP_FT_SHA384;
+using ::WPA_KEY_MGMT_FT_PSK_SHA256;
+using ::WPA_KEY_MGMT_FT_PSK_SHA384;
+using ::WPA_KEY_MGMT_NONE;
+using ::WPA_KEY_MGMT_PASN;
+using ::WPA_KEY_MGMT_SAE;
// APF capabilities supported by the iface.
struct PacketFilterCapabilities {
@@ -517,6 +536,8 @@
std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v2*>&)>;
using on_rtt_results_callback_v3 =
std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v3*>&)>;
+using on_rtt_results_callback_v4 =
+ std::function<void(wifi_request_id, const std::vector<const wifi_rtt_result_v4*>&)>;
// Callback for ring buffer data.
using on_ring_buffer_data_callback = std::function<void(
@@ -705,12 +726,17 @@
wifi_error startRttRangeRequestV3(const std::string& iface_name, wifi_request_id id,
const std::vector<wifi_rtt_config_v3>& rtt_configs,
const on_rtt_results_callback_v3& on_results_callback);
+ wifi_error startRttRangeRequestV4(const std::string& iface_name, wifi_request_id id,
+ const std::vector<wifi_rtt_config_v4>& rtt_configs,
+ const on_rtt_results_callback_v4& on_results_callback);
wifi_error cancelRttRangeRequest(const std::string& iface_name, wifi_request_id id,
const std::vector<std::array<uint8_t, ETH_ALEN>>& mac_addrs);
std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities(const std::string& iface_name);
std::pair<wifi_error, wifi_rtt_capabilities_v3> getRttCapabilitiesV3(
const std::string& iface_name);
+ std::pair<wifi_error, wifi_rtt_capabilities_v4> getRttCapabilitiesV4(
+ const std::string& iface_name);
std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo(const std::string& iface_name);
wifi_error enableRttResponder(const std::string& iface_name, wifi_request_id id,
const wifi_channel_info& channel_hint, uint32_t max_duration_secs,
diff --git a/wifi/aidl/default/wifi_legacy_hal_stubs.cpp b/wifi/aidl/default/wifi_legacy_hal_stubs.cpp
index 878abf0..d39894e 100644
--- a/wifi/aidl/default/wifi_legacy_hal_stubs.cpp
+++ b/wifi/aidl/default/wifi_legacy_hal_stubs.cpp
@@ -180,7 +180,9 @@
populateStubFor(&hal_fn->wifi_set_mlo_mode);
populateStubFor(&hal_fn->wifi_get_supported_iface_concurrency_matrix);
populateStubFor(&hal_fn->wifi_get_rtt_capabilities_v3);
+ populateStubFor(&hal_fn->wifi_get_rtt_capabilities_v4);
populateStubFor(&hal_fn->wifi_rtt_range_request_v3);
+ populateStubFor(&hal_fn->wifi_rtt_range_request_v4);
populateStubFor(&hal_fn->wifi_twt_get_capabilities);
populateStubFor(&hal_fn->wifi_twt_register_events);
populateStubFor(&hal_fn->wifi_twt_session_setup);
diff --git a/wifi/aidl/default/wifi_rtt_controller.cpp b/wifi/aidl/default/wifi_rtt_controller.cpp
index 9dee45c..99dafe8 100644
--- a/wifi/aidl/default/wifi_rtt_controller.cpp
+++ b/wifi/aidl/default/wifi_rtt_controller.cpp
@@ -136,13 +136,46 @@
ndk::ScopedAStatus WifiRttController::rangeRequestInternal(
int32_t cmd_id, const std::vector<RttConfig>& rtt_configs) {
- // Try 11mc & 11az ranging (v3)
+ // Try 11az secure, 11az non-secure & 11mc ranging (v4)
+ std::vector<legacy_hal::wifi_rtt_config_v4> legacy_configs_v4;
+ if (!aidl_struct_util::convertAidlVectorOfRttConfigToLegacyV4(rtt_configs,
+ &legacy_configs_v4)) {
+ return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
+ }
+ std::weak_ptr<WifiRttController> weak_ptr_this = weak_ptr_this_;
+ const auto& on_results_callback_v4 =
+ [weak_ptr_this](legacy_hal::wifi_request_id id,
+ const std::vector<const legacy_hal::wifi_rtt_result_v4*>& results) {
+ const auto shared_ptr_this = weak_ptr_this.lock();
+ if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
+ LOG(ERROR) << "v4 Callback invoked on an invalid object";
+ return;
+ }
+ std::vector<RttResult> aidl_results;
+ if (!aidl_struct_util::convertLegacyVectorOfRttResultV4ToAidl(results,
+ &aidl_results)) {
+ LOG(ERROR) << "Failed to convert rtt results v4 to AIDL structs";
+ return;
+ }
+ for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
+ if (!callback->onResults(id, aidl_results).isOk()) {
+ LOG(ERROR) << "Failed to invoke the v4 callback";
+ }
+ }
+ };
+ legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequestV4(
+ ifname_, cmd_id, legacy_configs_v4, on_results_callback_v4);
+
+ if (legacy_status != legacy_hal::WIFI_ERROR_NOT_SUPPORTED) {
+ return createWifiStatusFromLegacyError(legacy_status);
+ }
+
+ // Fallback to 11az non-secure & 11mc ranging (v3)
std::vector<legacy_hal::wifi_rtt_config_v3> legacy_configs_v3;
if (!aidl_struct_util::convertAidlVectorOfRttConfigToLegacyV3(rtt_configs,
&legacy_configs_v3)) {
return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
}
- std::weak_ptr<WifiRttController> weak_ptr_this = weak_ptr_this_;
const auto& on_results_callback_v3 =
[weak_ptr_this](legacy_hal::wifi_request_id id,
const std::vector<const legacy_hal::wifi_rtt_result_v3*>& results) {
@@ -163,8 +196,8 @@
}
}
};
- legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->startRttRangeRequestV3(
- ifname_, cmd_id, legacy_configs_v3, on_results_callback_v3);
+ legacy_status = legacy_hal_.lock()->startRttRangeRequestV3(ifname_, cmd_id, legacy_configs_v3,
+ on_results_callback_v3);
if (legacy_status != legacy_hal::WIFI_ERROR_NOT_SUPPORTED) {
return createWifiStatusFromLegacyError(legacy_status);
@@ -236,31 +269,46 @@
std::pair<RttCapabilities, ndk::ScopedAStatus> WifiRttController::getCapabilitiesInternal() {
legacy_hal::wifi_error legacy_status;
legacy_hal::wifi_rtt_capabilities_v3 legacy_caps_v3;
- std::tie(legacy_status, legacy_caps_v3) = legacy_hal_.lock()->getRttCapabilitiesV3(ifname_);
- // Try v3 API first, if it is not supported fallback.
- if (legacy_status == legacy_hal::WIFI_ERROR_NOT_SUPPORTED) {
- legacy_hal::wifi_rtt_capabilities legacy_caps;
- std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRttCapabilities(ifname_);
- if (legacy_status != legacy_hal::WIFI_SUCCESS) {
- return {RttCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
- }
+ legacy_hal::wifi_rtt_capabilities_v4 legacy_caps_v4;
+ // Try v4 first
+ std::tie(legacy_status, legacy_caps_v4) = legacy_hal_.lock()->getRttCapabilitiesV4(ifname_);
+ if (legacy_status == legacy_hal::WIFI_SUCCESS) {
RttCapabilities aidl_caps;
- if (!aidl_struct_util::convertLegacyRttCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
+ if (!aidl_struct_util::convertLegacyRttCapabilitiesV4ToAidl(legacy_caps_v4, &aidl_caps)) {
return {RttCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
}
return {aidl_caps, ndk::ScopedAStatus::ok()};
}
- if (legacy_status != legacy_hal::WIFI_SUCCESS) {
- return {RttCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
+ // If not supported, fallback to v3
+ if (legacy_status == legacy_hal::WIFI_ERROR_NOT_SUPPORTED) {
+ std::tie(legacy_status, legacy_caps_v3) = legacy_hal_.lock()->getRttCapabilitiesV3(ifname_);
+ if (legacy_status == legacy_hal::WIFI_SUCCESS) {
+ RttCapabilities aidl_caps;
+ if (!aidl_struct_util::convertLegacyRttCapabilitiesV3ToAidl(legacy_caps_v3,
+ &aidl_caps)) {
+ return {RttCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
+ }
+ return {aidl_caps, ndk::ScopedAStatus::ok()};
+ }
}
- RttCapabilities aidl_caps;
- if (!aidl_struct_util::convertLegacyRttCapabilitiesV3ToAidl(legacy_caps_v3, &aidl_caps)) {
- return {RttCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
+ // If not supported, fallback to default
+ if (legacy_status == legacy_hal::WIFI_ERROR_NOT_SUPPORTED) {
+ legacy_hal::wifi_rtt_capabilities legacy_caps;
+ std::tie(legacy_status, legacy_caps) = legacy_hal_.lock()->getRttCapabilities(ifname_);
+ if (legacy_status == legacy_hal::WIFI_SUCCESS) {
+ RttCapabilities aidl_caps;
+ if (!aidl_struct_util::convertLegacyRttCapabilitiesToAidl(legacy_caps, &aidl_caps)) {
+ return {RttCapabilities{}, createWifiStatus(WifiStatusCode::ERROR_UNKNOWN)};
+ }
+ return {aidl_caps, ndk::ScopedAStatus::ok()};
+ }
}
- return {aidl_caps, ndk::ScopedAStatus::ok()};
+
+ // Error, if all failed
+ return {RttCapabilities{}, createWifiStatusFromLegacyError(legacy_status)};
}
ndk::ScopedAStatus WifiRttController::setLciInternal(int32_t cmd_id, const RttLciInformation& lci) {
diff --git a/wifi/legacy_headers/include/hardware_legacy/wifi_hal.h b/wifi/legacy_headers/include/hardware_legacy/wifi_hal.h
index c68cdf6..a757954 100644
--- a/wifi/legacy_headers/include/hardware_legacy/wifi_hal.h
+++ b/wifi/legacy_headers/include/hardware_legacy/wifi_hal.h
@@ -790,10 +790,13 @@
wifi_rtt_config[], wifi_rtt_event_handler);
wifi_error (* wifi_rtt_range_request_v3)(wifi_request_id, wifi_interface_handle, unsigned,
wifi_rtt_config_v3[], wifi_rtt_event_handler_v3);
+ wifi_error (*wifi_rtt_range_request_v4)(wifi_request_id, wifi_interface_handle, unsigned,
+ wifi_rtt_config_v4[], wifi_rtt_event_handler_v4);
wifi_error (* wifi_rtt_range_cancel)(wifi_request_id, wifi_interface_handle, unsigned,
mac_addr[]);
wifi_error (* wifi_get_rtt_capabilities)(wifi_interface_handle, wifi_rtt_capabilities *);
wifi_error (* wifi_get_rtt_capabilities_v3)(wifi_interface_handle, wifi_rtt_capabilities_v3 *);
+ wifi_error (*wifi_get_rtt_capabilities_v4)(wifi_interface_handle, wifi_rtt_capabilities_v4*);
wifi_error (* wifi_rtt_get_responder_info)(wifi_interface_handle iface,
wifi_rtt_responder *responder_info);
wifi_error (* wifi_enable_responder)(wifi_request_id id, wifi_interface_handle iface,