Streamline bta/dm/bta_dm_act::bta_dm_set_encryption (69f77513) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/dm/bta_dm_act.cc

+45 −18

Original line number	Diff line number	Diff line
		@@ -3208,6 +3208,16 @@ void bta_dm_eir_update_uuid(uint16_t uuid16, bool adding) {
		}
		#endif

		static tBTA_DM_PEER_DEVICE* find_connected_device(
		const RawAddress& bd_addr, UNUSED_ATTR tBT_TRANSPORT transport) {
		for (uint8_t i = 0; i < bta_dm_cb.device_list.count; i++) {
		if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr == bd_addr &&
		bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_CONNECTED)
		return &bta_dm_cb.device_list.peer_device[i];
		}
		return nullptr;
		}

		/*******************************************************************************
		*
		* Function bta_dm_encrypt_cback
		@@ -3263,29 +3273,35 @@ void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
		void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
		tBTA_DM_ENCRYPT_CBACK* p_callback,
		tBTM_BLE_SEC_ACT sec_act) {
		uint8_t i;

		APPL_TRACE_DEBUG("bta_dm_set_encryption"); // todo
		if (!p_callback) {
		APPL_TRACE_ERROR("bta_dm_set_encryption callback is not provided");
		if (p_callback == nullptr) {
		LOG_ERROR("bta_dm_set_encryption callback is not provided");
		return;
		}
		for (i = 0; i < bta_dm_cb.device_list.count; i++) {
		if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr == bd_addr &&
		bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_CONNECTED)
		break;

		tBTA_DM_PEER_DEVICE* device = find_connected_device(bd_addr, transport);
		if (device == nullptr) {
		LOG_ERROR("Unable to find active ACL connection device:%s transport:%s",
		PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());
		return;
		}
		if (i < bta_dm_cb.device_list.count) {
		if (bta_dm_cb.device_list.peer_device[i].p_encrypt_cback) {
		APPL_TRACE_ERROR("earlier enc was not done for same device");

		if (device->p_encrypt_cback) {
		LOG_ERROR(
		"Unable to start encryption as already in progress peer:%s "
		"transport:%s",
		PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());
		(*p_callback)(bd_addr, transport, BTA_BUSY);
		return;
		}

		if (BTM_SetEncryption(bd_addr, transport, bta_dm_encrypt_cback, NULL,
		sec_act) == BTM_CMD_STARTED) {
		bta_dm_cb.device_list.peer_device[i].p_encrypt_cback = p_callback;
		}
		device->p_encrypt_cback = p_callback;
		LOG_DEBUG("Started encryption peer:%s transport:%s",
		PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());
		} else {
		LOG_ERROR("Unable to start encryption process peer:%s transport:%s",
		PRIVATE_ADDRESS(bd_addr), bt_transport_text(transport).c_str());
		}
		}

		@@ -4078,3 +4094,14 @@ void bta_dm_process_delete_key_RC_to_unpair(const RawAddress& bd_addr)
		bta_dm_cb.p_sec_cback(BTA_DM_REPORT_BONDING_EVT, &param);
		}

		namespace bluetooth {
		namespace legacy {
		namespace testing {
		tBTA_DM_PEER_DEVICE* allocate_device_for(const RawAddress& bd_addr,
		tBT_TRANSPORT transport) {
		return ::allocate_device_for(bd_addr, transport);
		}

		} // namespace testing
		} // namespace legacy
		} // namespace bluetooth

system/bta/test/bta_dm_test.cc

+97 −0

Original line number	Diff line number	Diff line
		@@ -18,14 +18,21 @@
		#include <base/location.h>
		#include <gtest/gtest.h>

		#include <chrono>

		#include "bta/dm/bta_dm_int.h"
		#include "bta/hf_client/bta_hf_client_int.h"
		#include "bta/include/bta_api.h"
		#include "bta/include/bta_dm_api.h"
		#include "bta/include/bta_hf_client_api.h"
		#include "btif/include/stack_manager.h"
		#include "common/message_loop_thread.h"
		#include "stack/include/btm_status.h"
		#include "test/mock/mock_osi_alarm.h"
		#include "test/mock/mock_stack_acl.h"
		#include "test/mock/mock_stack_btm_sec.h"

		using namespace std::chrono_literals;

		std::map<std::string, int> mock_function_count_map;

		@@ -39,6 +46,12 @@ class MessageLoop;

		namespace {
		constexpr uint8_t kUnusedTimer = BTA_ID_MAX;

		const char* test_flags[] = {
		"INIT_logging_debug_enabled_for_all=true",
		nullptr,
		};

		} // namespace

		struct alarm_t {
		@@ -50,6 +63,7 @@ class BtaDmTest : public testing::Test {
		protected:
		void SetUp() override {
		mock_function_count_map.clear();
		bluetooth::common::InitFlags::Load(test_flags);
		test::mock::osi_alarm::alarm_new.body = [](const char* name) -> alarm_t* {
		return new alarm_t(name);
		};
		@@ -175,3 +189,86 @@ TEST_F(BtaDmTest, disable_second_pass_with_acl_links) {
		test::mock::stack_acl::BTM_GetNumAclLinks = {};
		test::mock::osi_alarm::alarm_set_on_mloop = {};
		}

		namespace {

		struct BTA_DM_ENCRYPT_CBACK_parms {
		const RawAddress bd_addr;
		tBT_TRANSPORT transport;
		tBTA_STATUS result;
		};

		std::queue<BTA_DM_ENCRYPT_CBACK_parms> BTA_DM_ENCRYPT_CBACK_queue;

		void BTA_DM_ENCRYPT_CBACK(const RawAddress& bd_addr, tBT_TRANSPORT transport,
		tBTA_STATUS result) {
		BTA_DM_ENCRYPT_CBACK_queue.push({bd_addr, transport, result});
		}

		} // namespace

		namespace bluetooth {
		namespace legacy {
		namespace testing {
		tBTA_DM_PEER_DEVICE* allocate_device_for(const RawAddress& bd_addr,
		tBT_TRANSPORT transport);
		} // namespace testing
		} // namespace legacy
		} // namespace bluetooth

		TEST_F(BtaDmTest, bta_dm_set_encryption) {
		const RawAddress bd_addr{{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}};
		const tBT_TRANSPORT transport{BT_TRANSPORT_LE};
		const tBTM_BLE_SEC_ACT sec_act{BTM_BLE_SEC_NONE};

		// Callback not provided
		bta_dm_set_encryption(bd_addr, transport, nullptr, sec_act);

		// Device connection does not exist
		bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);

		// Setup a connected device
		tBTA_DM_PEER_DEVICE* device =
		bluetooth::legacy::testing::allocate_device_for(bd_addr, transport);
		ASSERT_TRUE(device != nullptr);
		device->conn_state = BTA_DM_CONNECTED;
		device->p_encrypt_cback = nullptr;

		// Setup a device that is busy with another encryption
		// Fake indication that the encryption is in progress with non-null callback
		device->p_encrypt_cback = BTA_DM_ENCRYPT_CBACK;
		bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);
		ASSERT_EQ(0, mock_function_count_map["BTM_SetEncryption"]);
		ASSERT_EQ(1UL, BTA_DM_ENCRYPT_CBACK_queue.size());
		auto params = BTA_DM_ENCRYPT_CBACK_queue.front();
		BTA_DM_ENCRYPT_CBACK_queue.pop();
		ASSERT_EQ(BTA_BUSY, params.result);
		device->p_encrypt_cback = nullptr;

		// Setup a device that fails encryption
		test::mock::stack_btm_sec::BTM_SetEncryption.body =
		[](const RawAddress& bd_addr, tBT_TRANSPORT transport,
		tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
		tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {
		return BTM_MODE_UNSUPPORTED;
		};

		bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);
		ASSERT_EQ(1, mock_function_count_map["BTM_SetEncryption"]);
		ASSERT_EQ(0UL, BTA_DM_ENCRYPT_CBACK_queue.size());
		device->p_encrypt_cback = nullptr;

		// Setup a device that successfully starts encryption
		test::mock::stack_btm_sec::BTM_SetEncryption.body =
		[](const RawAddress& bd_addr, tBT_TRANSPORT transport,
		tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
		tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS { return BTM_CMD_STARTED; };

		bta_dm_set_encryption(bd_addr, transport, BTA_DM_ENCRYPT_CBACK, sec_act);
		ASSERT_EQ(2, mock_function_count_map["BTM_SetEncryption"]);
		ASSERT_EQ(0UL, BTA_DM_ENCRYPT_CBACK_queue.size());
		ASSERT_NE(nullptr, device->p_encrypt_cback);

		test::mock::stack_btm_sec::BTM_SetEncryption = {};
		BTA_DM_ENCRYPT_CBACK_queue = {};
		}

system/test/mock/mock_stack_btm_sec.cc

+15 −0

Original line number	Diff line number	Diff line
		@@ -46,6 +46,7 @@ extern std::map<std::string, int> mock_function_count_map;
		#include "stack/include/btm_status.h"
		#include "stack/include/l2cap_security_interface.h"
		#include "stack/smp/smp_int.h"
		#include "test/mock/mock_stack_btm_sec.h"
		#include "types/raw_address.h"

		#ifndef UNUSED_ATTR
		@@ -146,11 +147,25 @@ tBTM_STATUS BTM_SecBondCancel(const RawAddress& bd_addr) {
		mock_function_count_map[__func__]++;
		return BTM_SUCCESS;
		}
		namespace test {
		namespace mock {
		namespace stack_btm_sec {

		struct BTM_SetEncryption BTM_SetEncryption;

		}
		} // namespace mock
		} // namespace test

		tBTM_STATUS BTM_SetEncryption(const RawAddress& bd_addr,
		tBT_TRANSPORT transport,
		tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
		tBTM_BLE_SEC_ACT sec_act) {
		mock_function_count_map[__func__]++;
		if (test::mock::stack_btm_sec::BTM_SetEncryption.body) {
		return test::mock::stack_btm_sec::BTM_SetEncryption.body(
		bd_addr, transport, p_callback, p_ref_data, sec_act);
		}
		return BTM_SUCCESS;
		}
		tBTM_STATUS btm_sec_bond_by_transport(const RawAddress& bd_addr,

system/test/mock/mock_stack_btm_sec.h

0 → 100644

+42 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 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.
		*/

		#include <map>
		#include <string>

		extern std::map<std::string, int> mock_function_count_map;

		namespace test {
		namespace mock {
		namespace stack_btm_sec {

		// Function state capture and return values, if needed
		struct BTM_SetEncryption {
		std::function<tBTM_STATUS(const RawAddress& bd_addr, tBT_TRANSPORT transport,
		tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
		tBTM_BLE_SEC_ACT sec_act)>
		body{};
		tBTM_STATUS operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport,
		tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
		tBTM_BLE_SEC_ACT sec_act) {
		return body(bd_addr, transport, p_callback, p_ref_data, sec_act);
		};
		};
		extern struct BTM_SetEncryption BTM_SetEncryption;

		} // namespace stack_btm_sec
		} // namespace mock
		} // namespace test