From 38e8db5d92f498181b8a5964d4581ca2cd26e551 Mon Sep 17 00:00:00 2001 From: Nate Jiang Date: Fri, 2 Dec 2022 17:30:27 -0800 Subject: [PATCH] Add Shim layer for new HAL about Aware pairing Bug: 249185683 Test: None Change-Id: I87792a2b44afc6fb0d127b3b90f28e369e551242 --- wifi/aidl/default/aidl_struct_util.cpp | 419 +++++++++++++++++++- wifi/aidl/default/aidl_struct_util.h | 21 + wifi/aidl/default/wifi_legacy_hal.cpp | 107 ++++- wifi/aidl/default/wifi_legacy_hal.h | 39 ++ wifi/aidl/default/wifi_legacy_hal_stubs.cpp | 4 + wifi/aidl/default/wifi_nan_iface.cpp | 186 +++++++++ wifi/aidl/default/wifi_nan_iface.h | 16 + 7 files changed, 780 insertions(+), 12 deletions(-) diff --git a/wifi/aidl/default/aidl_struct_util.cpp b/wifi/aidl/default/aidl_struct_util.cpp index 3087d6654b..83fd587431 100644 --- a/wifi/aidl/default/aidl_struct_util.cpp +++ b/wifi/aidl/default/aidl_struct_util.cpp @@ -1261,6 +1261,165 @@ legacy_hal::NanDataPathChannelCfg convertAidlNanDataPathChannelCfgToLegacy( CHECK(false); } +legacy_hal::NanPairingRequestType convertAidlNanPairingRequestTypeToLegacy( + NanPairingRequestType type) { + switch (type) { + case NanPairingRequestType::NAN_PAIRING_SETUP: + return legacy_hal::NAN_PAIRING_SETUP; + case NanPairingRequestType::NAN_PAIRING_VERIFICATION: + return legacy_hal::NAN_PAIRING_VERIFICATION; + } + LOG(FATAL); +} + +NanPairingRequestType convertLegacyNanPairingRequestTypeToAidl( + legacy_hal::NanPairingRequestType type) { + switch (type) { + case legacy_hal::NAN_PAIRING_SETUP: + return NanPairingRequestType::NAN_PAIRING_SETUP; + case legacy_hal::NAN_PAIRING_VERIFICATION: + return NanPairingRequestType::NAN_PAIRING_VERIFICATION; + } + LOG(FATAL); +} + +legacy_hal::Akm convertAidlAkmTypeToLegacy(NanPairingAkm type) { + switch (type) { + case NanPairingAkm::SAE: + return legacy_hal::SAE; + case NanPairingAkm::PASN: + return legacy_hal::PASN; + } + LOG(FATAL); +} + +NanPairingAkm convertLegacyAkmTypeToAidl(legacy_hal::Akm type) { + switch (type) { + case legacy_hal::SAE: + return NanPairingAkm::SAE; + case legacy_hal::PASN: + return NanPairingAkm::PASN; + } + LOG(FATAL); +} + +uint16_t convertAidlBootstrappingMethodToLegacy(NanBootstrappingMethod type) { + switch (type) { + case NanBootstrappingMethod::BOOTSTRAPPING_OPPORTUNISTIC_MASK: + return NAN_PAIRING_BOOTSTRAPPING_OPPORTUNISTIC_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK: + return NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK: + return NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_QR_DISPLAY_MASK: + return NAN_PAIRING_BOOTSTRAPPING_QR_DISPLAY_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_NFC_TAG_MASK: + return NAN_PAIRING_BOOTSTRAPPING_NFC_TAG_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK: + return NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK: + return NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_QR_SCAN_MASK: + return NAN_PAIRING_BOOTSTRAPPING_QR_SCAN_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_NFC_READER_MASK: + return NAN_PAIRING_BOOTSTRAPPING_NFC_READER_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_SERVICE_MANAGED_MASK: + return NAN_PAIRING_BOOTSTRAPPING_SERVICE_MANAGED_MASK; + case NanBootstrappingMethod::BOOTSTRAPPING_HANDSHAKE_SHIP_MASK: + return NAN_PAIRING_BOOTSTRAPPING_HANDSHAKE_SHIP_MASK; + } + LOG(FATAL); +} + +NanBootstrappingMethod convertLegacyBootstrappingMethodToAidl(uint16_t type) { + switch (type) { + case NAN_PAIRING_BOOTSTRAPPING_OPPORTUNISTIC_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_OPPORTUNISTIC_MASK; + case NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_DISPLAY_MASK; + case NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_DISPLAY_MASK; + case NAN_PAIRING_BOOTSTRAPPING_QR_DISPLAY_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_QR_DISPLAY_MASK; + case NAN_PAIRING_BOOTSTRAPPING_NFC_TAG_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_NFC_TAG_MASK; + case NAN_PAIRING_BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_PIN_CODE_KEYPAD_MASK; + case NAN_PAIRING_BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_PASSPHRASE_KEYPAD_MASK; + case NAN_PAIRING_BOOTSTRAPPING_QR_SCAN_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_QR_SCAN_MASK; + case NAN_PAIRING_BOOTSTRAPPING_NFC_READER_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_NFC_READER_MASK; + case NAN_PAIRING_BOOTSTRAPPING_SERVICE_MANAGED_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_SERVICE_MANAGED_MASK; + case NAN_PAIRING_BOOTSTRAPPING_HANDSHAKE_SHIP_MASK: + return NanBootstrappingMethod::BOOTSTRAPPING_HANDSHAKE_SHIP_MASK; + } + LOG(FATAL); + return {}; +} + +bool covertAidlPairingConfigToLegacy(const NanPairingConfig& aidl_config, + legacy_hal::NanPairingConfig* legacy_config) { + if (!legacy_config) { + LOG(ERROR) << "covertAidlPairingConfigToLegacy: legacy_config is null"; + return false; + } + legacy_config->enable_pairing_setup = aidl_config.enablePairingSetup ? 0x1 : 0x0; + legacy_config->enable_pairing_cache = aidl_config.enablePairingCache ? 0x1 : 0x0; + legacy_config->enable_pairing_verification = aidl_config.enablePairingVerification ? 0x1 : 0x0; + legacy_config->supported_bootstrapping_methods = aidl_config.supportedBootstrappingMethods; + return true; +} + +bool convertLegacyPairingConfigToAidl(const legacy_hal::NanPairingConfig& legacy_config, + NanPairingConfig* aidl_config) { + if (!aidl_config) { + LOG(ERROR) << "convertLegacyPairingConfigToAidl: aidl_nira is null"; + return false; + } + *aidl_config = {}; + aidl_config->enablePairingSetup = legacy_config.enable_pairing_setup == 0x1; + aidl_config->enablePairingCache = legacy_config.enable_pairing_cache == 0x1; + aidl_config->enablePairingVerification = legacy_config.enable_pairing_verification == 0x1; + aidl_config->supportedBootstrappingMethods = legacy_config.supported_bootstrapping_methods; + return true; +} + +bool convertLegacyNiraToAidl(const legacy_hal::NanIdentityResolutionAttribute& legacy_nira, + NanIdentityResolutionAttribute* aidl_nira) { + if (!aidl_nira) { + LOG(ERROR) << "convertLegacyNiraToAidl: aidl_nira is null"; + return false; + } + *aidl_nira = {}; + aidl_nira->nonce = std::array(); + std::copy(legacy_nira.nonce, legacy_nira.nonce + 8, std::begin(aidl_nira->nonce)); + aidl_nira->tag = std::array(); + std::copy(legacy_nira.tag, legacy_nira.tag + 8, std::begin(aidl_nira->tag)); + return true; +} + +bool convertLegacyNpsaToAidl(const legacy_hal::NpkSecurityAssociation& legacy_npsa, + NpkSecurityAssociation* aidl_npsa) { + if (!aidl_npsa) { + LOG(ERROR) << "convertLegacyNiraToAidl: aidl_nira is null"; + return false; + } + *aidl_npsa = {}; + aidl_npsa->peerNanIdentityKey = std::array(); + std::copy(legacy_npsa.peer_nan_identity_key, legacy_npsa.peer_nan_identity_key + 16, + std::begin(aidl_npsa->peerNanIdentityKey)); + aidl_npsa->localNanIdentityKey = std::array(); + std::copy(legacy_npsa.local_nan_identity_key, legacy_npsa.local_nan_identity_key + 16, + std::begin(aidl_npsa->localNanIdentityKey)); + aidl_npsa->npk = std::array(); + std::copy(legacy_npsa.npk.pmk, legacy_npsa.npk.pmk + 32, std::begin(aidl_npsa->npk)); + aidl_npsa->akm = convertLegacyAkmTypeToAidl(legacy_npsa.akm); + return true; +} + NanStatusCode convertLegacyNanStatusTypeToAidl(legacy_hal::NanStatusType type) { switch (type) { case legacy_hal::NAN_STATUS_SUCCESS: @@ -1289,6 +1448,10 @@ NanStatusCode convertLegacyNanStatusTypeToAidl(legacy_hal::NanStatusType type) { return NanStatusCode::FOLLOWUP_TX_QUEUE_FULL; case legacy_hal::NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED: return NanStatusCode::UNSUPPORTED_CONCURRENCY_NAN_DISABLED; + case legacy_hal::NAN_STATUS_INVALID_PAIRING_ID: + return NanStatusCode::INVALID_PAIRING_ID; + case legacy_hal::NAN_STATUS_INVALID_BOOTSTRAPPING_ID: + return NanStatusCode::INVALID_BOOTSTRAPPING_ID; } CHECK(false); } @@ -1679,6 +1842,12 @@ bool convertAidlNanPublishRequestToLegacy(const NanPublishRequest& aidl_request, legacy_request->service_responder_policy = aidl_request.autoAcceptDataPathRequests ? legacy_hal::NAN_SERVICE_ACCEPT_POLICY_ALL : legacy_hal::NAN_SERVICE_ACCEPT_POLICY_NONE; + memcpy(legacy_request->nan_identity_key, aidl_request.identityKey.data(), NAN_IDENTITY_KEY_LEN); + if (!covertAidlPairingConfigToLegacy(aidl_request.pairingConfig, + &legacy_request->nan_pairing_config)) { + LOG(ERROR) << "convertAidlNanPublishRequestToLegacy: invalid pairing config"; + return false; + } return true; } @@ -1819,7 +1988,12 @@ bool convertAidlNanSubscribeRequestToLegacy(const NanSubscribeRequest& aidl_requ for (int i = 0; i < legacy_request->num_intf_addr_present; i++) { memcpy(legacy_request->intf_addr[i], aidl_request.intfAddr[i].data.data(), 6); } - + memcpy(legacy_request->nan_identity_key, aidl_request.identityKey.data(), NAN_IDENTITY_KEY_LEN); + if (!covertAidlPairingConfigToLegacy(aidl_request.pairingConfig, + &legacy_request->nan_pairing_config)) { + LOG(ERROR) << "convertAidlNanSubscribeRequestToLegacy: invalid pairing config"; + return false; + } return true; } @@ -2068,7 +2242,9 @@ bool convertLegacyNanCapabilitiesResponseToAidl(const legacy_hal::NanCapabilitie aidl_response->supportedCipherSuites = static_cast(legacy_response.cipher_suites_supported); aidl_response->instantCommunicationModeSupportFlag = legacy_response.is_instant_mode_supported; - + aidl_response->supports6g = legacy_response.is_6g_supported; + aidl_response->supportsHe = legacy_response.is_he_supported; + aidl_response->supportsPairing = legacy_response.is_pairing_supported; return true; } @@ -2105,6 +2281,16 @@ bool convertLegacyNanMatchIndToAidl(const legacy_hal::NanMatchInd& legacy_ind, aidl_ind->rangingIndicationType = static_cast(legacy_ind.range_info.ranging_event_type); aidl_ind->scid = std::vector(legacy_ind.scid, legacy_ind.scid + legacy_ind.scid_len); + + if (!convertLegacyNiraToAidl(legacy_ind.nira, &aidl_ind->peerNira)) { + LOG(ERROR) << "convertLegacyNanMatchIndToAidl: invalid NIRA"; + return false; + } + if (!convertLegacyPairingConfigToAidl(legacy_ind.peer_pairing_config, + &aidl_ind->peerPairingConfig)) { + LOG(ERROR) << "convertLegacyNanMatchIndToAidl: invalid pairing config"; + return false; + } return true; } @@ -2861,6 +3047,235 @@ bool convertLegacyRadioCombinationsMatrixToAidl( return true; } +bool convertAidlNanPairingInitiatorRequestToLegacy(const NanPairingRequest& aidl_request, + legacy_hal::NanPairingRequest* legacy_request) { + if (!legacy_request) { + LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: " + "legacy_request is null"; + return false; + } + *legacy_request = {}; + + legacy_request->requestor_instance_id = aidl_request.peerId; + memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6); + legacy_request->nan_pairing_request_type = + convertAidlNanPairingRequestTypeToLegacy(aidl_request.requestType); + legacy_request->enable_pairing_cache = aidl_request.enablePairingCache; + + memcpy(legacy_request->nan_identity_key, aidl_request.pairingIdentityKey.data(), + NAN_IDENTITY_KEY_LEN); + + legacy_request->is_opportunistic = + aidl_request.securityConfig.securityType == NanPairingSecurityType::OPPORTUNISTIC ? 1 + : 0; + legacy_request->akm = convertAidlAkmTypeToLegacy(aidl_request.securityConfig.akm); + if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PMK) { + legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK; + legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size(); + if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) { + LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: " + "invalid pmk_len"; + return false; + } + memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(), + legacy_request->key_info.body.pmk_info.pmk_len); + } + if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PASSPHRASE) { + legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE; + legacy_request->key_info.body.passphrase_info.passphrase_len = + aidl_request.securityConfig.passphrase.size(); + if (legacy_request->key_info.body.passphrase_info.passphrase_len < + NAN_SECURITY_MIN_PASSPHRASE_LEN) { + LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: " + "passphrase_len too small"; + return false; + } + if (legacy_request->key_info.body.passphrase_info.passphrase_len > + NAN_SECURITY_MAX_PASSPHRASE_LEN) { + LOG(ERROR) << "convertAidlNanPairingInitiatorRequestToLegacy: " + "passphrase_len too large"; + return false; + } + memcpy(legacy_request->key_info.body.passphrase_info.passphrase, + aidl_request.securityConfig.passphrase.data(), + legacy_request->key_info.body.passphrase_info.passphrase_len); + } + + return true; +} + +bool convertAidlNanPairingIndicationResponseToLegacy( + const NanRespondToPairingIndicationRequest& aidl_request, + legacy_hal::NanPairingIndicationResponse* legacy_request) { + if (!legacy_request) { + LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: " + "legacy_request is null"; + return false; + } + *legacy_request = {}; + + legacy_request->pairing_instance_id = aidl_request.pairingInstanceId; + legacy_request->nan_pairing_request_type = + convertAidlNanPairingRequestTypeToLegacy(aidl_request.requestType); + legacy_request->enable_pairing_cache = aidl_request.enablePairingCache; + + memcpy(legacy_request->nan_identity_key, aidl_request.pairingIdentityKey.data(), + NAN_IDENTITY_KEY_LEN); + + legacy_request->is_opportunistic = + aidl_request.securityConfig.securityType == NanPairingSecurityType::OPPORTUNISTIC ? 1 + : 0; + legacy_request->akm = convertAidlAkmTypeToLegacy(aidl_request.securityConfig.akm); + legacy_request->rsp_code = + aidl_request.acceptRequest ? NAN_PAIRING_REQUEST_ACCEPT : NAN_PAIRING_REQUEST_REJECT; + if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PMK) { + legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PMK; + legacy_request->key_info.body.pmk_info.pmk_len = aidl_request.securityConfig.pmk.size(); + if (legacy_request->key_info.body.pmk_info.pmk_len != NAN_PMK_INFO_LEN) { + LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: " + "invalid pmk_len"; + return false; + } + memcpy(legacy_request->key_info.body.pmk_info.pmk, aidl_request.securityConfig.pmk.data(), + legacy_request->key_info.body.pmk_info.pmk_len); + } + if (aidl_request.securityConfig.securityType == NanPairingSecurityType::PASSPHRASE) { + legacy_request->key_info.key_type = legacy_hal::NAN_SECURITY_KEY_INPUT_PASSPHRASE; + legacy_request->key_info.body.passphrase_info.passphrase_len = + aidl_request.securityConfig.passphrase.size(); + if (legacy_request->key_info.body.passphrase_info.passphrase_len < + NAN_SECURITY_MIN_PASSPHRASE_LEN) { + LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: " + "passphrase_len too small"; + return false; + } + if (legacy_request->key_info.body.passphrase_info.passphrase_len > + NAN_SECURITY_MAX_PASSPHRASE_LEN) { + LOG(ERROR) << "convertAidlNanPairingIndicationResponseToLegacy: " + "passphrase_len too large"; + return false; + } + memcpy(legacy_request->key_info.body.passphrase_info.passphrase, + aidl_request.securityConfig.passphrase.data(), + legacy_request->key_info.body.passphrase_info.passphrase_len); + } + + return true; +} + +bool convertAidlNanBootstrappingInitiatorRequestToLegacy( + const NanBootstrappingRequest& aidl_request, + legacy_hal::NanBootstrappingRequest* legacy_request) { + if (!legacy_request) { + LOG(ERROR) << "convertAidlNanBootstrappingInitiatorRequestToLegacy: " + "legacy_request is null"; + return false; + } + *legacy_request = {}; + + legacy_request->requestor_instance_id = aidl_request.peerId; + memcpy(legacy_request->peer_disc_mac_addr, aidl_request.peerDiscMacAddr.data(), 6); + legacy_request->request_bootstrapping_method = + convertAidlBootstrappingMethodToLegacy(aidl_request.requestBootstrappingMethod); + + return true; +} + +bool convertAidlNanBootstrappingIndicationResponseToLegacy( + const NanBootstrappingResponse& aidl_request, + legacy_hal::NanBootstrappingIndicationResponse* legacy_request) { + if (!legacy_request) { + LOG(ERROR) << "convertAidlNanBootstrappingIndicationResponseToLegacy: " + "legacy_request is null"; + return false; + } + *legacy_request = {}; + + legacy_request->service_instance_id = aidl_request.bootstrappingInstanceId; + legacy_request->rsp_code = aidl_request.acceptRequest ? NAN_BOOTSTRAPPING_REQUEST_ACCEPT + : NAN_BOOTSTRAPPING_REQUEST_REJECT; + + return true; +} + +bool convertLegacyNanPairingRequestIndToAidl(const legacy_hal::NanPairingRequestInd& legacy_ind, + NanPairingRequestInd* aidl_ind) { + if (!aidl_ind) { + LOG(ERROR) << "convertLegacyNanPairingRequestIndToAidl: aidl_ind is null"; + return false; + } + *aidl_ind = {}; + + aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id; + aidl_ind->peerId = legacy_ind.requestor_instance_id; + aidl_ind->peerDiscMacAddr = std::array(); + std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6, + std::begin(aidl_ind->peerDiscMacAddr)); + aidl_ind->pairingInstanceId = legacy_ind.pairing_instance_id; + aidl_ind->enablePairingCache = legacy_ind.enable_pairing_cache == 1; + aidl_ind->requestType = + convertLegacyNanPairingRequestTypeToAidl(legacy_ind.nan_pairing_request_type); + if (!convertLegacyNiraToAidl(legacy_ind.nira, &aidl_ind->peerNira)) { + return false; + } + return true; +} + +bool convertLegacyNanPairingConfirmIndToAidl(const legacy_hal::NanPairingConfirmInd& legacy_ind, + NanPairingConfirmInd* aidl_ind) { + if (!aidl_ind) { + LOG(ERROR) << "convertLegacyNanPairingRequestIndToAidl: aidl_ind is null"; + return false; + } + *aidl_ind = {}; + + aidl_ind->pairingInstanceId = legacy_ind.pairing_instance_id; + aidl_ind->enablePairingCache = legacy_ind.enable_pairing_cache == 1; + aidl_ind->requestType = + convertLegacyNanPairingRequestTypeToAidl(legacy_ind.nan_pairing_request_type); + aidl_ind->pairingSuccess = legacy_ind.rsp_code == NAN_PAIRING_REQUEST_ACCEPT; + aidl_ind->status.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code); + if (!convertLegacyNpsaToAidl(legacy_ind.npk_security_association, &aidl_ind->npksa)) { + return false; + } + return true; +} + +bool convertLegacyNanBootstrappingRequestIndToAidl( + const legacy_hal::NanBootstrappingRequestInd& legacy_ind, + NanBootstrappingRequestInd* aidl_ind) { + if (!aidl_ind) { + LOG(ERROR) << "convertLegacyNanBootstrappingRequestIndToAidl: aidl_ind is null"; + return false; + } + *aidl_ind = {}; + + aidl_ind->discoverySessionId = legacy_ind.publish_subscribe_id; + aidl_ind->peerId = legacy_ind.requestor_instance_id; + aidl_ind->peerDiscMacAddr = std::array(); + std::copy(legacy_ind.peer_disc_mac_addr, legacy_ind.peer_disc_mac_addr + 6, + std::begin(aidl_ind->peerDiscMacAddr)); + aidl_ind->bootstrappingInstanceId = legacy_ind.bootstrapping_instance_id; + aidl_ind->requestBootstrappingMethod = + convertLegacyBootstrappingMethodToAidl(legacy_ind.request_bootstrapping_method); + return true; +} + +bool convertLegacyNanBootstrappingConfirmIndToAidl( + const legacy_hal::NanBootstrappingConfirmInd& legacy_ind, + NanBootstrappingConfirmInd* aidl_ind) { + if (!aidl_ind) { + LOG(ERROR) << "convertLegacyNanBootstrappingConfirmIndToAidl: aidl_ind is null"; + return false; + } + *aidl_ind = {}; + + aidl_ind->bootstrappingInstanceId = legacy_ind.bootstrapping_instance_id; + aidl_ind->acceptRequest = legacy_ind.rsp_code == NAN_BOOTSTRAPPING_REQUEST_ACCEPT; + aidl_ind->reasonCode.status = convertLegacyNanStatusTypeToAidl(legacy_ind.reason_code); + return true; +} + bool convertLegacyWifiChipCapabilitiesToAidl( const legacy_hal::wifi_chip_capabilities& legacy_chip_capabilities, WifiChipCapabilities& aidl_chip_capabilities) { diff --git a/wifi/aidl/default/aidl_struct_util.h b/wifi/aidl/default/aidl_struct_util.h index ac86755382..693e680564 100644 --- a/wifi/aidl/default/aidl_struct_util.h +++ b/wifi/aidl/default/aidl_struct_util.h @@ -176,6 +176,27 @@ bool convertLegacyWifiRateInfoToAidl(const legacy_hal::wifi_rate& legacy_rate, bool convertLegacyWifiChipCapabilitiesToAidl( const legacy_hal::wifi_chip_capabilities& legacy_chip_capabilities, WifiChipCapabilities& aidl_chip_capabilities); +bool convertAidlNanPairingInitiatorRequestToLegacy(const NanPairingRequest& aidl_request, + legacy_hal::NanPairingRequest* legacy_request); +bool convertAidlNanPairingIndicationResponseToLegacy( + const NanRespondToPairingIndicationRequest& aidl_response, + legacy_hal::NanPairingIndicationResponse* legacy_response); +bool convertAidlNanBootstrappingInitiatorRequestToLegacy( + const NanBootstrappingRequest& aidl_request, + legacy_hal::NanBootstrappingRequest* legacy_request); +bool convertAidlNanBootstrappingIndicationResponseToLegacy( + const NanBootstrappingResponse& aidl_response, + legacy_hal::NanBootstrappingIndicationResponse* legacy_response); +bool convertLegacyNanPairingRequestIndToAidl(const legacy_hal::NanPairingRequestInd& legacy_ind, + NanPairingRequestInd* aidl_ind); +bool convertLegacyNanPairingConfirmIndToAidl(const legacy_hal::NanPairingConfirmInd& legacy_ind, + NanPairingConfirmInd* aidl_ind); +bool convertLegacyNanBootstrappingRequestIndToAidl( + const legacy_hal::NanBootstrappingRequestInd& legacy_ind, + NanBootstrappingRequestInd* aidl_ind); +bool convertLegacyNanBootstrappingConfirmIndToAidl( + const legacy_hal::NanBootstrappingConfirmInd& legacy_ind, + NanBootstrappingConfirmInd* aidl_ind); } // namespace aidl_struct_util } // namespace wifi } // namespace hardware diff --git a/wifi/aidl/default/wifi_legacy_hal.cpp b/wifi/aidl/default/wifi_legacy_hal.cpp index 83f368e0bf..3acc1ae0f0 100644 --- a/wifi/aidl/default/wifi_legacy_hal.cpp +++ b/wifi/aidl/default/wifi_legacy_hal.cpp @@ -334,6 +334,40 @@ void onAsyncNanEventScheduleUpdate(NanDataPathScheduleUpdateInd* event) { } } +std::function on_nan_event_pairing_request_user_callback; +void onAsyncNanEventPairingRequest(NanPairingRequestInd* event) { + const auto lock = aidl_sync_util::acquireGlobalLock(); + if (on_nan_event_pairing_request_user_callback && event) { + on_nan_event_pairing_request_user_callback(*event); + } +} + +std::function on_nan_event_pairing_confirm_user_callback; +void onAsyncNanEventPairingConfirm(NanPairingConfirmInd* event) { + const auto lock = aidl_sync_util::acquireGlobalLock(); + if (on_nan_event_pairing_confirm_user_callback && event) { + on_nan_event_pairing_confirm_user_callback(*event); + } +} + +std::function + on_nan_event_bootstrapping_request_user_callback; +void onAsyncNanEventBootstrappingRequest(NanBootstrappingRequestInd* event) { + const auto lock = aidl_sync_util::acquireGlobalLock(); + if (on_nan_event_bootstrapping_request_user_callback && event) { + on_nan_event_bootstrapping_request_user_callback(*event); + } +} + +std::function + on_nan_event_bootstrapping_confirm_user_callback; +void onAsyncNanEventBootstrappingConfirm(NanBootstrappingConfirmInd* event) { + const auto lock = aidl_sync_util::acquireGlobalLock(); + if (on_nan_event_bootstrapping_confirm_user_callback && event) { + on_nan_event_bootstrapping_confirm_user_callback(*event); + } +} + // Callbacks for the various TWT operations. std::function on_twt_event_setup_response_callback; void onAsyncTwtEventSetupResponse(TwtSetupResponse* event) { @@ -1298,6 +1332,12 @@ wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(const std::string& iface_n on_nan_event_tca_user_callback = user_callbacks.on_event_tca; on_nan_event_beacon_sdf_payload_user_callback = user_callbacks.on_event_beacon_sdf_payload; on_nan_event_data_path_request_user_callback = user_callbacks.on_event_data_path_request; + on_nan_event_pairing_request_user_callback = user_callbacks.on_event_pairing_request; + on_nan_event_pairing_confirm_user_callback = user_callbacks.on_event_pairing_confirm; + on_nan_event_bootstrapping_request_user_callback = + user_callbacks.on_event_bootstrapping_request; + on_nan_event_bootstrapping_confirm_user_callback = + user_callbacks.on_event_bootstrapping_confirm; on_nan_event_data_path_confirm_user_callback = user_callbacks.on_event_data_path_confirm; on_nan_event_data_path_end_user_callback = user_callbacks.on_event_data_path_end; on_nan_event_transmit_follow_up_user_callback = user_callbacks.on_event_transmit_follow_up; @@ -1305,16 +1345,29 @@ wifi_error WifiLegacyHal::nanRegisterCallbackHandlers(const std::string& iface_n on_nan_event_range_report_user_callback = user_callbacks.on_event_range_report; on_nan_event_schedule_update_user_callback = user_callbacks.on_event_schedule_update; - return global_func_table_.wifi_nan_register_handler( - getIfaceHandle(iface_name), - {onAsyncNanNotifyResponse, onAsyncNanEventPublishReplied, - onAsyncNanEventPublishTerminated, onAsyncNanEventMatch, onAsyncNanEventMatchExpired, - onAsyncNanEventSubscribeTerminated, onAsyncNanEventFollowup, - onAsyncNanEventDiscEngEvent, onAsyncNanEventDisabled, onAsyncNanEventTca, - onAsyncNanEventBeaconSdfPayload, onAsyncNanEventDataPathRequest, - onAsyncNanEventDataPathConfirm, onAsyncNanEventDataPathEnd, - onAsyncNanEventTransmitFollowUp, onAsyncNanEventRangeRequest, - onAsyncNanEventRangeReport, onAsyncNanEventScheduleUpdate}); + return global_func_table_.wifi_nan_register_handler(getIfaceHandle(iface_name), + {onAsyncNanNotifyResponse, + onAsyncNanEventPublishReplied, + onAsyncNanEventPublishTerminated, + onAsyncNanEventMatch, + onAsyncNanEventMatchExpired, + onAsyncNanEventSubscribeTerminated, + onAsyncNanEventFollowup, + onAsyncNanEventDiscEngEvent, + onAsyncNanEventDisabled, + onAsyncNanEventTca, + onAsyncNanEventBeaconSdfPayload, + onAsyncNanEventDataPathRequest, + onAsyncNanEventDataPathConfirm, + onAsyncNanEventDataPathEnd, + onAsyncNanEventTransmitFollowUp, + onAsyncNanEventRangeRequest, + onAsyncNanEventRangeReport, + onAsyncNanEventScheduleUpdate, + onAsyncNanEventPairingRequest, + onAsyncNanEventPairingConfirm, + onAsyncNanEventBootstrappingRequest, + onAsyncNanEventBootstrappingConfirm}); } wifi_error WifiLegacyHal::nanEnableRequest(const std::string& iface_name, transaction_id id, @@ -1429,6 +1482,36 @@ wifi_error WifiLegacyHal::nanDataIndicationResponse(const std::string& iface_nam &msg_internal); } +wifi_error WifiLegacyHal::nanPairingRequest(const std::string& iface_name, transaction_id id, + const NanPairingRequest& msg) { + NanPairingRequest msg_internal(msg); + return global_func_table_.wifi_nan_pairing_request(id, getIfaceHandle(iface_name), + &msg_internal); +} + +wifi_error WifiLegacyHal::nanPairingIndicationResponse(const std::string& iface_name, + transaction_id id, + const NanPairingIndicationResponse& msg) { + NanPairingIndicationResponse msg_internal(msg); + return global_func_table_.wifi_nan_pairing_indication_response(id, getIfaceHandle(iface_name), + &msg_internal); +} + +wifi_error WifiLegacyHal::nanBootstrappingRequest(const std::string& iface_name, transaction_id id, + const NanBootstrappingRequest& msg) { + NanBootstrappingRequest msg_internal(msg); + return global_func_table_.wifi_nan_bootstrapping_request(id, getIfaceHandle(iface_name), + &msg_internal); +} + +wifi_error WifiLegacyHal::nanBootstrappingIndicationResponse( + const std::string& iface_name, transaction_id id, + const NanBootstrappingIndicationResponse& msg) { + NanBootstrappingIndicationResponse msg_internal(msg); + return global_func_table_.wifi_nan_bootstrapping_indication_response( + id, getIfaceHandle(iface_name), &msg_internal); +} + typedef struct { u8 num_ndp_instances; NanDataPathId ndp_instance_id; @@ -1746,6 +1829,10 @@ void WifiLegacyHal::invalidate() { on_nan_event_tca_user_callback = nullptr; on_nan_event_beacon_sdf_payload_user_callback = nullptr; on_nan_event_data_path_request_user_callback = nullptr; + on_nan_event_pairing_request_user_callback = nullptr; + on_nan_event_pairing_confirm_user_callback = nullptr; + on_nan_event_bootstrapping_request_user_callback = nullptr; + on_nan_event_bootstrapping_confirm_user_callback = nullptr; on_nan_event_data_path_confirm_user_callback = nullptr; on_nan_event_data_path_end_user_callback = nullptr; on_nan_event_transmit_follow_up_user_callback = nullptr; diff --git a/wifi/aidl/default/wifi_legacy_hal.h b/wifi/aidl/default/wifi_legacy_hal.h index c40118e233..7b434139a2 100644 --- a/wifi/aidl/default/wifi_legacy_hal.h +++ b/wifi/aidl/default/wifi_legacy_hal.h @@ -36,6 +36,7 @@ namespace wifi { namespace legacy_hal { // Import all the types defined inside the legacy HAL header files into this // namespace. +using ::Akm; using ::chre_nan_rtt_state; using ::frame_info; using ::frame_type; @@ -44,6 +45,8 @@ using ::FRAME_TYPE_ETHERNET_II; using ::FRAME_TYPE_UNKNOWN; using ::fw_roaming_state_t; using ::mac_addr; +using ::NAN_BOOTSTRAPPING_INITIATOR_RESPONSE; +using ::NAN_BOOTSTRAPPING_RESPONDER_RESPONSE; using ::NAN_CHANNEL_24G_BAND; using ::NAN_CHANNEL_5G_BAND_HIGH; using ::NAN_CHANNEL_5G_BAND_LOW; @@ -65,6 +68,10 @@ using ::NAN_GET_CAPABILITIES; using ::NAN_MATCH_ALG_MATCH_CONTINUOUS; using ::NAN_MATCH_ALG_MATCH_NEVER; using ::NAN_MATCH_ALG_MATCH_ONCE; +using ::NAN_PAIRING_INITIATOR_RESPONSE; +using ::NAN_PAIRING_RESPONDER_RESPONSE; +using ::NAN_PAIRING_SETUP; +using ::NAN_PAIRING_VERIFICATION; using ::NAN_PUBLISH_TYPE_SOLICITED; using ::NAN_PUBLISH_TYPE_UNSOLICITED; using ::NAN_PUBLISH_TYPE_UNSOLICITED_SOLICITED; @@ -97,7 +104,9 @@ using ::NAN_SSI_REQUIRED_IN_MATCH_IND; using ::NAN_STATUS_ALREADY_ENABLED; using ::NAN_STATUS_FOLLOWUP_QUEUE_FULL; using ::NAN_STATUS_INTERNAL_FAILURE; +using ::NAN_STATUS_INVALID_BOOTSTRAPPING_ID; using ::NAN_STATUS_INVALID_NDP_ID; +using ::NAN_STATUS_INVALID_PAIRING_ID; using ::NAN_STATUS_INVALID_PARAM; using ::NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID; using ::NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID; @@ -117,6 +126,12 @@ using ::NAN_TX_TYPE_BROADCAST; using ::NAN_TX_TYPE_UNICAST; using ::NAN_USE_SRF; using ::NanBeaconSdfPayloadInd; +using ::NanBootstrappingConfirmInd; +using ::NanBootstrappingIndicationResponse; +using ::NanBootstrappingRequest; +using ::NanBootstrappingRequestInd; +using ::NanBootstrappingRequestResponse; +using ::NanBootstrappingResponseCode; using ::NanCapabilities; using ::NanChannelInfo; using ::NanConfigRequest; @@ -131,9 +146,18 @@ using ::NanDisabledInd; using ::NanDiscEngEventInd; using ::NanEnableRequest; using ::NanFollowupInd; +using ::NanIdentityResolutionAttribute; using ::NanMatchAlg; using ::NanMatchExpiredInd; using ::NanMatchInd; +using ::NanPairingConfig; +using ::NanPairingConfirmInd; +using ::NanPairingIndicationResponse; +using ::NanPairingRequest; +using ::NanPairingRequestInd; +using ::NanPairingRequestResponse; +using ::NanPairingRequestType; +using ::NanPairingResponseCode; using ::NanPublishCancelRequest; using ::NanPublishRequest; using ::NanPublishTerminatedInd; @@ -150,6 +174,8 @@ using ::NanSubscribeType; using ::NanTransmitFollowupInd; using ::NanTransmitFollowupRequest; using ::NanTxType; +using ::NpkSecurityAssociation; +using ::PASN; using ::ROAMING_DISABLE; using ::ROAMING_ENABLE; using ::RTT_PEER_AP; @@ -189,6 +215,7 @@ using ::RX_PKT_FATE_FW_DROP_NOBUFS; using ::RX_PKT_FATE_FW_DROP_OTHER; using ::RX_PKT_FATE_FW_QUEUED; using ::RX_PKT_FATE_SUCCESS; +using ::SAE; using ::ssid_t; using ::transaction_id; using ::TX_PKT_FATE_ACKED; @@ -412,6 +439,10 @@ struct NanCallbackHandlers { std::function on_event_range_request; std::function on_event_range_report; std::function on_event_schedule_update; + std::function on_event_pairing_request; + std::function on_event_pairing_confirm; + std::function on_event_bootstrapping_request; + std::function on_event_bootstrapping_confirm; }; // Full scan results contain IE info and are hence passed by reference, to @@ -653,6 +684,14 @@ class WifiLegacyHal { const NanDataPathInitiatorRequest& msg); wifi_error nanDataIndicationResponse(const std::string& iface_name, transaction_id id, const NanDataPathIndicationResponse& msg); + wifi_error nanPairingRequest(const std::string& iface_name, transaction_id id, + const NanPairingRequest& msg); + wifi_error nanPairingIndicationResponse(const std::string& iface_name, transaction_id id, + const NanPairingIndicationResponse& msg); + wifi_error nanBootstrappingRequest(const std::string& iface_name, transaction_id id, + const NanBootstrappingRequest& msg); + wifi_error nanBootstrappingIndicationResponse(const std::string& iface_name, transaction_id id, + const NanBootstrappingIndicationResponse& msg); wifi_error nanDataEnd(const std::string& iface_name, transaction_id id, uint32_t ndpInstanceId); // AP functions. wifi_error setCountryCode(const std::string& iface_name, const std::array code); diff --git a/wifi/aidl/default/wifi_legacy_hal_stubs.cpp b/wifi/aidl/default/wifi_legacy_hal_stubs.cpp index 777789442d..a0cb2c071d 100644 --- a/wifi/aidl/default/wifi_legacy_hal_stubs.cpp +++ b/wifi/aidl/default/wifi_legacy_hal_stubs.cpp @@ -126,6 +126,10 @@ bool initHalFuncTableWithStubs(wifi_hal_fn* hal_fn) { populateStubFor(&hal_fn->wifi_nan_data_interface_delete); populateStubFor(&hal_fn->wifi_nan_data_request_initiator); populateStubFor(&hal_fn->wifi_nan_data_indication_response); + populateStubFor(&hal_fn->wifi_nan_pairing_request); + populateStubFor(&hal_fn->wifi_nan_pairing_indication_response); + populateStubFor(&hal_fn->wifi_nan_bootstrapping_request); + populateStubFor(&hal_fn->wifi_nan_bootstrapping_indication_response); populateStubFor(&hal_fn->wifi_nan_data_end); populateStubFor(&hal_fn->wifi_get_packet_filter_capabilities); populateStubFor(&hal_fn->wifi_set_packet_filter); diff --git a/wifi/aidl/default/wifi_nan_iface.cpp b/wifi/aidl/default/wifi_nan_iface.cpp index 9edef09b7b..ce6902da8a 100644 --- a/wifi/aidl/default/wifi_nan_iface.cpp +++ b/wifi/aidl/default/wifi_nan_iface.cpp @@ -205,6 +205,46 @@ void WifiNanIface::registerCallbackHandlers() { } break; } + case legacy_hal::NAN_PAIRING_INITIATOR_RESPONSE: { + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->notifyInitiatePairingResponse( + id, nanStatus, + msg.body.pairing_request_response.paring_instance_id) + .isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + break; + } + case legacy_hal::NAN_PAIRING_RESPONDER_RESPONSE: { + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->notifyRespondToPairingIndicationResponse(id, nanStatus).isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + break; + } + case legacy_hal::NAN_BOOTSTRAPPING_INITIATOR_RESPONSE: { + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->notifyInitiateBootstrappingResponse( + id, nanStatus, + msg.body.bootstrapping_request_response + .bootstrapping_instance_id) + .isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + break; + } + case legacy_hal::NAN_BOOTSTRAPPING_RESPONDER_RESPONSE: { + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->notifyRespondToBootstrappingIndicationResponse(id, nanStatus) + .isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + break; + } case legacy_hal::NAN_RESPONSE_BEACON_SDF_PAYLOAD: /* fall through */ case legacy_hal::NAN_RESPONSE_TCA: @@ -421,6 +461,85 @@ void WifiNanIface::registerCallbackHandlers() { } }; + callback_handlers.on_event_pairing_request = + [weak_ptr_this](const legacy_hal::NanPairingRequestInd& msg) { + const auto shared_ptr_this = weak_ptr_this.lock(); + if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { + LOG(ERROR) << "Callback invoked on an invalid object"; + return; + } + NanPairingRequestInd aidl_struct; + if (!aidl_struct_util::convertLegacyNanPairingRequestIndToAidl(msg, &aidl_struct)) { + LOG(ERROR) << "Failed to convert nan capabilities response"; + return; + } + + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->eventPairingRequest(aidl_struct).isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + }; + callback_handlers.on_event_pairing_confirm = + [weak_ptr_this](const legacy_hal::NanPairingConfirmInd& msg) { + const auto shared_ptr_this = weak_ptr_this.lock(); + if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { + LOG(ERROR) << "Callback invoked on an invalid object"; + return; + } + NanPairingConfirmInd aidl_struct; + if (!aidl_struct_util::convertLegacyNanPairingConfirmIndToAidl(msg, &aidl_struct)) { + LOG(ERROR) << "Failed to convert nan capabilities response"; + return; + } + + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->eventPairingConfirm(aidl_struct).isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + }; + callback_handlers.on_event_bootstrapping_request = + [weak_ptr_this](const legacy_hal::NanBootstrappingRequestInd& msg) { + const auto shared_ptr_this = weak_ptr_this.lock(); + if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { + LOG(ERROR) << "Callback invoked on an invalid object"; + return; + } + NanBootstrappingRequestInd aidl_struct; + if (!aidl_struct_util::convertLegacyNanBootstrappingRequestIndToAidl( + msg, &aidl_struct)) { + LOG(ERROR) << "Failed to convert nan capabilities response"; + return; + } + + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->eventBootstrappingRequest(aidl_struct).isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + }; + callback_handlers.on_event_bootstrapping_confirm = + [weak_ptr_this](const legacy_hal::NanBootstrappingConfirmInd& msg) { + const auto shared_ptr_this = weak_ptr_this.lock(); + if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) { + LOG(ERROR) << "Callback invoked on an invalid object"; + return; + } + NanBootstrappingConfirmInd aidl_struct; + if (!aidl_struct_util::convertLegacyNanBootstrappingConfirmIndToAidl( + msg, &aidl_struct)) { + LOG(ERROR) << "Failed to convert nan capabilities response"; + return; + } + + for (const auto& callback : shared_ptr_this->getEventCallbacks()) { + if (!callback->eventBootstrappingConfirm(aidl_struct).isOk()) { + LOG(ERROR) << "Failed to invoke the callback"; + } + } + }; + callback_handlers.on_event_beacon_sdf_payload = [](const legacy_hal::NanBeaconSdfPayloadInd& /* msg */) { LOG(ERROR) << "on_event_beacon_sdf_payload - should not be called"; @@ -611,6 +730,32 @@ ndk::ScopedAStatus WifiNanIface::terminateDataPathRequest(char16_t in_cmdId, in_ndpInstanceId); } +ndk::ScopedAStatus WifiNanIface::initiatePairingRequest(char16_t in_cmdId, + const NanPairingRequest& in_msg) { + return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, + &WifiNanIface::initiatePairingRequestInternal, in_cmdId, in_msg); +} + +ndk::ScopedAStatus WifiNanIface::respondToPairingIndicationRequest( + char16_t in_cmdId, const NanRespondToPairingIndicationRequest& in_msg) { + return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, + &WifiNanIface::respondToPairingIndicationRequestInternal, in_cmdId, + in_msg); +} + +ndk::ScopedAStatus WifiNanIface::initiateBootstrappingRequest( + char16_t in_cmdId, const NanBootstrappingRequest& in_msg) { + return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, + &WifiNanIface::initiateBootstrappingRequestInternal, in_cmdId, in_msg); +} + +ndk::ScopedAStatus WifiNanIface::respondToBootstrappingIndicationRequest( + char16_t in_cmdId, const NanBootstrappingResponse& in_msg) { + return validateAndCall(this, WifiStatusCode::ERROR_WIFI_IFACE_INVALID, + &WifiNanIface::respondToBootstrappingIndicationRequestInternal, in_cmdId, + in_msg); +} + std::pair WifiNanIface::getNameInternal() { return {ifname_, ndk::ScopedAStatus::ok()}; } @@ -744,6 +889,47 @@ ndk::ScopedAStatus WifiNanIface::terminateDataPathRequestInternal(char16_t cmd_i legacy_hal_.lock()->nanDataEnd(ifname_, cmd_id, ndpInstanceId); return createWifiStatusFromLegacyError(legacy_status); } +ndk::ScopedAStatus WifiNanIface::initiatePairingRequestInternal(char16_t cmd_id, + const NanPairingRequest& msg) { + legacy_hal::NanPairingRequest legacy_msg; + if (!aidl_struct_util::convertAidlNanPairingInitiatorRequestToLegacy(msg, &legacy_msg)) { + return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); + } + legacy_hal::wifi_error legacy_status = + legacy_hal_.lock()->nanPairingRequest(ifname_, cmd_id, legacy_msg); + return createWifiStatusFromLegacyError(legacy_status); +} +ndk::ScopedAStatus WifiNanIface::respondToPairingIndicationRequestInternal( + char16_t cmd_id, const NanRespondToPairingIndicationRequest& msg) { + legacy_hal::NanPairingIndicationResponse legacy_msg; + if (!aidl_struct_util::convertAidlNanPairingIndicationResponseToLegacy(msg, &legacy_msg)) { + return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); + } + legacy_hal::wifi_error legacy_status = + legacy_hal_.lock()->nanPairingIndicationResponse(ifname_, cmd_id, legacy_msg); + return createWifiStatusFromLegacyError(legacy_status); +} +ndk::ScopedAStatus WifiNanIface::initiateBootstrappingRequestInternal( + char16_t cmd_id, const NanBootstrappingRequest& msg) { + legacy_hal::NanBootstrappingRequest legacy_msg; + if (!aidl_struct_util::convertAidlNanBootstrappingInitiatorRequestToLegacy(msg, &legacy_msg)) { + return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); + } + legacy_hal::wifi_error legacy_status = + legacy_hal_.lock()->nanBootstrappingRequest(ifname_, cmd_id, legacy_msg); + return createWifiStatusFromLegacyError(legacy_status); +} +ndk::ScopedAStatus WifiNanIface::respondToBootstrappingIndicationRequestInternal( + char16_t cmd_id, const NanBootstrappingResponse& msg) { + legacy_hal::NanBootstrappingIndicationResponse legacy_msg; + if (!aidl_struct_util::convertAidlNanBootstrappingIndicationResponseToLegacy(msg, + &legacy_msg)) { + return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS); + } + legacy_hal::wifi_error legacy_status = + legacy_hal_.lock()->nanBootstrappingIndicationResponse(ifname_, cmd_id, legacy_msg); + return createWifiStatusFromLegacyError(legacy_status); +} } // namespace wifi } // namespace hardware diff --git a/wifi/aidl/default/wifi_nan_iface.h b/wifi/aidl/default/wifi_nan_iface.h index 101890594c..591eca908e 100644 --- a/wifi/aidl/default/wifi_nan_iface.h +++ b/wifi/aidl/default/wifi_nan_iface.h @@ -78,6 +78,14 @@ class WifiNanIface : public BnWifiNanIface { char16_t in_cmdId, const NanRespondToDataPathIndicationRequest& in_msg) override; ndk::ScopedAStatus terminateDataPathRequest(char16_t in_cmdId, int32_t in_ndpInstanceId) override; + ndk::ScopedAStatus initiatePairingRequest(char16_t in_cmdId, + const NanPairingRequest& in_msg) override; + ndk::ScopedAStatus respondToPairingIndicationRequest( + char16_t in_cmdId, const NanRespondToPairingIndicationRequest& in_msg) override; + ndk::ScopedAStatus initiateBootstrappingRequest(char16_t in_cmdId, + const NanBootstrappingRequest& in_msg) override; + ndk::ScopedAStatus respondToBootstrappingIndicationRequest( + char16_t in_cmdId, const NanBootstrappingResponse& in_msg) override; protected: // Accessible to child class in the gTest suite. @@ -111,6 +119,14 @@ class WifiNanIface : public BnWifiNanIface { ndk::ScopedAStatus respondToDataPathIndicationRequestInternal( char16_t cmd_id, const NanRespondToDataPathIndicationRequest& msg); ndk::ScopedAStatus terminateDataPathRequestInternal(char16_t cmd_id, int32_t ndpInstanceId); + ndk::ScopedAStatus initiatePairingRequestInternal(char16_t cmd_id, + const NanPairingRequest& msg); + ndk::ScopedAStatus respondToPairingIndicationRequestInternal( + char16_t cmd_id, const NanRespondToPairingIndicationRequest& msg); + ndk::ScopedAStatus initiateBootstrappingRequestInternal(char16_t cmd_id, + const NanBootstrappingRequest& msg); + ndk::ScopedAStatus respondToBootstrappingIndicationRequestInternal( + char16_t cmd_id, const NanBootstrappingResponse& msg); // Overridden in the gTest suite. virtual std::set> getEventCallbacks();