Fix for hid disconnect with unknown channel am: 3e2d2b79e0 am: 48952e93dc am: a9eb0a39f1 (17fd6a16) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/Android.bp

+48 −0

Original line number	Diff line number	Diff line
		@@ -808,3 +808,51 @@ cc_test {
		},
		},
		}

		cc_test {
		name: "net_test_stack_hid",
		test_suites: ["device-tests"],
		host_supported: true,
		defaults: ["fluoride_defaults"],
		local_include_dirs: [
		"include",
		"test/common",
		],
		include_dirs: [
		"packages/modules/Bluetooth/system",
		],
		srcs: crypto_toolbox_srcs + [
		":TestStackL2cap",
		":TestStackSdp",
		":TestStackBtm",
		":TestStubLegacyTrace",
		"hid/hidd_api.cc",
		"hid/hidd_conn.cc",
		"hid/hidh_api.cc",
		"hid/hidh_conn.cc",
		"test/hid/stack_hid_test.cc",
		],
		static_libs: [
		"libbt-common",
		"libbt-protos-lite",
		"libbtdevice",
		"libbte",
		"libgmock",
		"liblog",
		"libosi",
		],
		shared_libs: [
		"libcrypto",
		"libprotobuf-cpp-lite",
		],
		sanitize: {
		address: true,
		all_undefined: true,
		cfi: true,
		integer_overflow: true,
		scs: true,
		diag: {
		undefined : true
		},
		},
		}

system/stack/hid/hidh_conn.cc

+6 −0

Original line number	Diff line number	Diff line
		@@ -270,6 +270,12 @@ static void hidh_try_repage(uint8_t dhandle) {

		static void hidh_on_l2cap_error(uint16_t l2cap_cid, uint16_t result) {
		auto dhandle = find_conn_by_cid(l2cap_cid);
		if (dhandle == kHID_HOST_MAX_DEVICES) {
		LOG_WARN("Received error for unknown device cid:0x%04x reason:%s",
		l2cap_cid,
		hci_reason_code_text(to_hci_reason_code(result)).c_str());
		return;
		}

		hidh_conn_disconnect(dhandle);

system/stack/test/hid/stack_hid_test.cc

0 → 100644

+77 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021 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 <gmock/gmock.h>
		#include <gtest/gtest.h>
		#include <cstring>
		#include <map>

		#include "common/message_loop_thread.h"
		#include "osi/include/log.h"
		#include "stack/hid/hidh_int.h"
		#include "stack/include/hci_error_code.h"
		#include "test/mock/mock_stack_l2cap_api.h"
		#include "types/bt_transport.h"
		#include "types/raw_address.h"

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

		bluetooth::common::MessageLoopThread* get_main_thread() { return nullptr; }
		tHCI_REASON btm_get_acl_disc_reason_code(void) { return HCI_SUCCESS; }

		bool BTM_IsAclConnectionUp(const RawAddress& remote_bda,
		tBT_TRANSPORT transport) {
		return true;
		}
		namespace {

		using testing::_;
		using testing::DoAll;
		using testing::NotNull;
		using testing::Pointee;
		using testing::Return;
		using testing::SaveArg;
		using testing::SaveArgPointee;
		using testing::StrEq;
		using testing::StrictMock;
		using testing::Test;

		class StackHidTest : public Test {
		public:
		protected:
		void SetUp() override { mock_function_count_map.clear(); }
		void TearDown() override {}
		};

		TEST_F(StackHidTest, disconnect_bad_cid) {
		tL2CAP_APPL_INFO l2cap_callbacks;

		test::mock::stack_l2cap_api::L2CA_Register2.body =
		[&l2cap_callbacks](uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info,
		bool enable_snoop, tL2CAP_ERTM_INFO* p_ertm_info,
		uint16_t my_mtu, uint16_t required_remote_mtu,
		uint16_t sec_level) {
		l2cap_callbacks = p_cb_info;
		return psm;
		};

		tHID_STATUS status = hidh_conn_reg();
		ASSERT_EQ(HID_SUCCESS, status);

		l2cap_callbacks.pL2CA_Error_Cb(123, 456);
		}

		} // namespace

system/test/Android.bp

+19 −0

Original line number	Diff line number	Diff line
		@@ -117,4 +117,23 @@ filegroup {
		],
		}

		filegroup {
		name: "TestStackSdp",
		srcs: [
		"mock/mock_stack_sdp*.cc",
		],
		}

		filegroup {
		name: "TestStackBtm",
		srcs: [
		"mock/mock_stack_btm*.cc",
		],
		}

		filegroup {
		name: "TestStubLegacyTrace",
		srcs: [
		"stub/legacy_trace.cc",
		],
		}

system/test/mock/mock_l2cap_l2c_api.cc

deleted100644 → 0

+0 −177

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

		/*
		* Generated mock file from original source file
		* Functions generated:33
		*/

		#include <map>
		#include <string>

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

		#include <cstdint>
		#include "stack/include/l2c_api.h"
		#include "types/raw_address.h"

		#ifndef UNUSED_ATTR
		#define UNUSED_ATTR
		#endif

		bool L2CA_ConnectCreditBasedRsp(const RawAddress& p_bd_addr, uint8_t id,
		std::vector<uint16_t>& accepted_lcids,
		uint16_t result, tL2CAP_LE_CFG_INFO* p_cfg) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_ConnectFixedChnl(uint16_t fixed_cid, const RawAddress& rem_bda) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_DisconnectLECocReq(uint16_t cid) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_DisconnectReq(uint16_t cid) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_GetPeerFeatures(const RawAddress& bd_addr, uint32_t* p_ext_feat,
		uint8_t* p_chnl_mask) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_GetPeerLECocConfig(uint16_t lcid, tL2CAP_LE_CFG_INFO* peer_cfg) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_GetRemoteCid(uint16_t lcid, uint16_t* rcid) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_IsLinkEstablished(const RawAddress& bd_addr,
		tBT_TRANSPORT transport) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_ReconfigCreditBasedConnsReq(const RawAddress& bda,
		std::vector<uint16_t>& lcids,
		tL2CAP_LE_CFG_INFO* p_cfg) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_RegisterFixedChannel(uint16_t fixed_cid,
		tL2CAP_FIXED_CHNL_REG* p_freg) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_RemoveFixedChnl(uint16_t fixed_cid, const RawAddress& rem_bda) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_SetAclPriority(const RawAddress& bd_addr, tL2CAP_PRIORITY priority) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_SetChnlFlushability(uint16_t cid, bool is_flushable) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_SetLeGattTimeout(const RawAddress& rem_bda, uint16_t idle_tout) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_SetIdleTimeoutByBdAddr(const RawAddress& bd_addr, uint16_t timeout,
		tBT_TRANSPORT transport) {
		mock_function_count_map[__func__]++;
		return false;
		}
		bool L2CA_SetTxPriority(uint16_t cid, tL2CAP_CHNL_PRIORITY priority) {
		mock_function_count_map[__func__]++;
		return false;
		}
		std::vector<uint16_t> L2CA_ConnectCreditBasedReq(uint16_t psm,
		const RawAddress& p_bd_addr,
		tL2CAP_LE_CFG_INFO* p_cfg) {
		mock_function_count_map[__func__]++;
		std::vector<uint16_t> v;
		return v;
		}
		tBT_TRANSPORT l2c_get_transport_from_fixed_cid(uint16_t fixed_cid) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_AllocateLePSM(void) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_ConnectLECocReq(uint16_t psm, const RawAddress& p_bd_addr,
		tL2CAP_LE_CFG_INFO* p_cfg, uint16_t sec_level) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_ConnectReq(uint16_t psm, const RawAddress& p_bd_addr) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_ConnectReq2(uint16_t psm, const RawAddress& p_bd_addr,
		uint16_t sec_level) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_FlushChannel(uint16_t lcid, uint16_t num_to_flush) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_Register(uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info,
		bool enable_snoop, tL2CAP_ERTM_INFO* p_ertm_info,
		uint16_t my_mtu, uint16_t required_remote_mtu) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_Register2(uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info,
		bool enable_snoop, tL2CAP_ERTM_INFO* p_ertm_info,
		uint16_t my_mtu, uint16_t required_remote_mtu,
		uint16_t sec_level) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_RegisterLECoc(uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info,
		uint16_t sec_level, tL2CAP_LE_CFG_INFO cfg) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint16_t L2CA_SendFixedChnlData(uint16_t fixed_cid, const RawAddress& rem_bda,
		BT_HDR* p_buf) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint8_t L2CA_DataWrite(uint16_t cid, BT_HDR* p_data) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint8_t L2CA_LECocDataWrite(uint16_t cid, BT_HDR* p_data) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		uint8_t L2CA_SetTraceLevel(uint8_t new_level) {
		mock_function_count_map[__func__]++;
		return 0;
		}
		void L2CA_Deregister(uint16_t psm) { mock_function_count_map[__func__]++; }
		void L2CA_DeregisterLECoc(uint16_t psm) { mock_function_count_map[__func__]++; }
		void L2CA_FreeLePSM(uint16_t psm) { mock_function_count_map[__func__]++; }