Merge "Rootcanal: Le resolving list hci cmds" (bcdc32db) · Commits · e / os / android_packages_modules_Bluetooth

system/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.cc

+70 −0

Original line number	Diff line number	Diff line
		@@ -209,6 +209,12 @@ DualModeController::DualModeController(const std::string& properties_filename, u
		SET_HANDLER(OpCode::READ_REMOTE_VERSION_INFORMATION, HciReadRemoteVersionInformation);
		SET_HANDLER(OpCode::LE_CONNECTION_UPDATE, HciLeConnectionUpdate);
		SET_HANDLER(OpCode::LE_START_ENCRYPTION, HciLeStartEncryption);
		SET_HANDLER(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST,
		HciLeAddDeviceToResolvingList);
		SET_HANDLER(OpCode::LE_REMOVE_DEVICE_FROM_RESOLVING_LIST,
		HciLeRemoveDeviceFromResolvingList);
		SET_HANDLER(OpCode::LE_CLEAR_RESOLVING_LIST, HciLeClearResolvingList);
		SET_HANDLER(OpCode::LE_SET_PRIVACY_MODE, HciLeSetPrivacyMode);
		// Testing Commands
		SET_HANDLER(OpCode::READ_LOOPBACK_MODE, HciReadLoopbackMode);
		SET_HANDLER(OpCode::WRITE_LOOPBACK_MODE, HciWriteLoopbackMode);
		@@ -1085,6 +1091,70 @@ void DualModeController::HciLeRemoveDeviceFromWhiteList(packets::PacketView<true
		SendCommandCompleteSuccess(OpCode::LE_REMOVE_DEVICE_FROM_WHITE_LIST);
		}

		void DualModeController::HciLeClearResolvingList(
		packets::PacketView<true> args) {
		ASSERT_LOG(args.size() == 0, "%s size=%zu", __func__, args.size());
		link_layer_controller_.LeResolvingListClear();
		SendCommandCompleteSuccess(OpCode::LE_CLEAR_RESOLVING_LIST);
		}

		void DualModeController::HciLeAddDeviceToResolvingList(
		packets::PacketView<true> args) {
		ASSERT_LOG(args.size() == 39, "%s size=%zu", __func__, args.size());

		if (link_layer_controller_.LeResolvingListFull()) {
		SendCommandCompleteOnlyStatus(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST,
		hci::Status::MEMORY_CAPACITY_EXCEEDED);
		return;
		}
		auto args_itr = args.begin();
		uint8_t addr_type = args_itr.extract<uint8_t>();
		Address address = args_itr.extract<Address>();
		std::array<uint8_t, LinkLayerController::kIrk_size> peerIrk;
		std::array<uint8_t, LinkLayerController::kIrk_size> localIrk;
		for (size_t irk_ind = 0; irk_ind < LinkLayerController::kIrk_size;
		irk_ind++) {
		peerIrk[irk_ind] = args_itr.extract<uint8_t>();
		}

		for (size_t irk_ind = 0; irk_ind < LinkLayerController::kIrk_size;
		irk_ind++) {
		localIrk[irk_ind] = args_itr.extract<uint8_t>();
		}

		link_layer_controller_.LeResolvingListAddDevice(address, addr_type, peerIrk,
		localIrk);
		SendCommandCompleteSuccess(OpCode::LE_ADD_DEVICE_TO_RESOLVING_LIST);
		}

		void DualModeController::HciLeRemoveDeviceFromResolvingList(
		packets::PacketView<true> args) {
		ASSERT_LOG(args.size() == 7, "%s size=%zu", __func__, args.size());

		auto args_itr = args.begin();
		uint8_t addr_type = args_itr.extract<uint8_t>();
		Address address = args_itr.extract<Address>();
		link_layer_controller_.LeResolvingListRemoveDevice(address, addr_type);
		SendCommandCompleteSuccess(OpCode::LE_REMOVE_DEVICE_FROM_RESOLVING_LIST);
		}

		void DualModeController::HciLeSetPrivacyMode(packets::PacketView<true> args) {
		ASSERT_LOG(args.size() == 8, "%s size=%zu", __func__, args.size());

		auto args_itr = args.begin();
		uint8_t peer_identity_address_type = args_itr.extract<uint8_t>();
		Address peer_identity_address = args_itr.extract<Address>();
		uint8_t privacy_mode = args_itr.extract<uint8_t>();

		if (link_layer_controller_.LeResolvingListContainsDevice(
		peer_identity_address, peer_identity_address_type)) {
		link_layer_controller_.LeSetPrivacyMode(
		peer_identity_address_type, peer_identity_address, privacy_mode);
		}

		SendCommandCompleteSuccess(OpCode::LE_SET_PRIVACY_MODE);
		}

		/*
		void DualModeController::HciLeReadRemoteUsedFeaturesRsp(uint16_t handle,
		uint64_t features) {

system/vendor_libs/test_vendor_lib/model/controller/dual_mode_controller.h

+12 −0

Original line number	Diff line number	Diff line
		@@ -380,6 +380,18 @@ class DualModeController : public Device {
		// 7.8.27
		void HciLeReadSupportedStates(packets::PacketView<true> args);

		// 7.8.38
		void HciLeAddDeviceToResolvingList(packets::PacketView<true> args);

		// 7.8.39
		void HciLeRemoveDeviceFromResolvingList(packets::PacketView<true> args);

		// 7.8.40
		void HciLeClearResolvingList(packets::PacketView<true> args);

		// 7.8.77
		void HciLeSetPrivacyMode(packets::PacketView<true> args);

		// Vendor-specific Commands

		void HciLeVendorSleepMode(packets::PacketView<true> args);

system/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.cc

+53 −0

Original line number	Diff line number	Diff line
		@@ -1311,6 +1311,8 @@ void LinkLayerController::LeWhiteListClear() {
		le_white_list_.clear();
		}

		void LinkLayerController::LeResolvingListClear() { le_resolving_list_.clear(); }

		void LinkLayerController::LeWhiteListAddDevice(Address addr, uint8_t addr_type) {
		std::tuple<Address, uint8_t> new_tuple = std::make_tuple(addr, addr_type);
		for (auto dev : le_white_list_) {
		@@ -1321,6 +1323,30 @@ void LinkLayerController::LeWhiteListAddDevice(Address addr, uint8_t addr_type)
		le_white_list_.emplace_back(new_tuple);
		}

		void LinkLayerController::LeResolvingListAddDevice(
		Address addr, uint8_t addr_type, std::array<uint8_t, kIrk_size> peerIrk,
		std::array<uint8_t, kIrk_size> localIrk) {
		std::tuple<Address, uint8_t, std::array<uint8_t, kIrk_size>,
		std::array<uint8_t, kIrk_size>>
		new_tuple = std::make_tuple(addr, addr_type, peerIrk, localIrk);
		for (size_t i = 0; i < le_white_list_.size(); i++) {
		auto curr = le_white_list_[i];
		if (std::get<0>(curr) == addr && std::get<1>(curr) == addr_type) {
		le_resolving_list_[i] = new_tuple;
		return;
		}
		}
		le_resolving_list_.emplace_back(new_tuple);
		}

		void LinkLayerController::LeSetPrivacyMode(uint8_t address_type, Address addr,
		uint8_t mode) {
		// set mode for addr
		LOG_INFO("address type = %d ", address_type);
		LOG_INFO("address = %s ", addr.ToString().c_str());
		LOG_INFO("mode = %d ", mode);
		}

		void LinkLayerController::LeWhiteListRemoveDevice(Address addr, uint8_t addr_type) {
		// TODO: Add checks to see if advertising, scanning, or a connection request
		// with the white list is ongoing.
		@@ -1332,6 +1358,18 @@ void LinkLayerController::LeWhiteListRemoveDevice(Address addr, uint8_t addr_typ
		}
		}

		void LinkLayerController::LeResolvingListRemoveDevice(Address addr,
		uint8_t addr_type) {
		// TODO: Add checks to see if advertising, scanning, or a connection request
		// with the white list is ongoing.
		for (size_t i = 0; i < le_white_list_.size(); i++) {
		auto curr = le_white_list_[i];
		if (std::get<0>(curr) == addr && std::get<1>(curr) == addr_type) {
		le_resolving_list_.erase(le_resolving_list_.begin() + i);
		}
		}
		}

		bool LinkLayerController::LeWhiteListContainsDevice(Address addr, uint8_t addr_type) {
		std::tuple<Address, uint8_t> sought_tuple = std::make_tuple(addr, addr_type);
		for (size_t i = 0; i < le_white_list_.size(); i++) {
		@@ -1342,10 +1380,25 @@ bool LinkLayerController::LeWhiteListContainsDevice(Address addr, uint8_t addr_t
		return false;
		}

		bool LinkLayerController::LeResolvingListContainsDevice(Address addr,
		uint8_t addr_type) {
		for (size_t i = 0; i < le_white_list_.size(); i++) {
		auto curr = le_white_list_[i];
		if (std::get<0>(curr) == addr && std::get<1>(curr) == addr_type) {
		return true;
		}
		}
		return false;
		}

		bool LinkLayerController::LeWhiteListFull() {
		return le_white_list_.size() >= properties_.GetLeWhiteListSize();
		}

		bool LinkLayerController::LeResolvingListFull() {
		return le_resolving_list_.size() >= properties_.GetLeResolvingListSize();
		}

		void LinkLayerController::Reset() {
		inquiry_state_ = Inquiry::InquiryState::STANDBY;
		last_inquiry_ = steady_clock::now();

system/vendor_libs/test_vendor_lib/model/controller/link_layer_controller.h

+13 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,8 @@ namespace test_vendor_lib {

		class LinkLayerController {
		public:
		static constexpr size_t kIrk_size = 16;

		LinkLayerController(const DeviceProperties& properties) : properties_(properties) {}
		hci::Status SendCommandToRemoteByAddress(hci::OpCode opcode, packets::PacketView<true> args, const Address& remote,
		bool use_public_address);
		@@ -118,6 +120,14 @@ class LinkLayerController {
		void LeWhiteListRemoveDevice(Address addr, uint8_t addr_type);
		bool LeWhiteListContainsDevice(Address addr, uint8_t addr_type);
		bool LeWhiteListFull();
		void LeResolvingListClear();
		void LeResolvingListAddDevice(Address addr, uint8_t addr_type,
		std::array<uint8_t, kIrk_size> peerIrk,
		std::array<uint8_t, kIrk_size> localIrk);
		void LeResolvingListRemoveDevice(Address addr, uint8_t addr_type);
		bool LeResolvingListContainsDevice(Address addr, uint8_t addr_type);
		bool LeResolvingListFull();
		void LeSetPrivacyMode(uint8_t address_type, Address addr, uint8_t mode);

		hci::Status SetLeAdvertisingEnable(uint8_t le_advertising_enable) {
		le_advertising_enable_ = le_advertising_enable;
		@@ -272,6 +282,9 @@ class LinkLayerController {
		std::vector<uint8_t> le_event_mask_;

		std::vector<std::tuple<Address, uint8_t>> le_white_list_;
		std::vector<std::tuple<Address, uint8_t, std::array<uint8_t, kIrk_size>,
		std::array<uint8_t, kIrk_size>>>
		le_resolving_list_;

		uint8_t le_advertising_enable_{false};
		std::chrono::steady_clock::time_point last_le_advertisement_;

system/vendor_libs/test_vendor_lib/model/devices/device_properties.cc

+13 −4

Original line number	Diff line number	Diff line
		@@ -45,10 +45,19 @@ bool ParseUint16t(base::StringPiece value, uint16_t* field) {
		namespace test_vendor_lib {

		DeviceProperties::DeviceProperties(const std::string& file_name)
		: acl_data_packet_size_(1024), sco_data_packet_size_(255), num_acl_data_packets_(10), num_sco_data_packets_(10),
		version_(static_cast<uint8_t>(hci::Version::V4_1)), revision_(0),
		lmp_pal_version_(static_cast<uint8_t>(hci::Version::V4_1)), manufacturer_name_(0), lmp_pal_subversion_(0),
		le_data_packet_length_(27), num_le_data_packets_(15), le_white_list_size_(15) {
		: acl_data_packet_size_(1024),
		sco_data_packet_size_(255),
		num_acl_data_packets_(10),
		num_sco_data_packets_(10),
		version_(static_cast<uint8_t>(hci::Version::V4_1)),
		revision_(0),
		lmp_pal_version_(static_cast<uint8_t>(hci::Version::V4_1)),
		manufacturer_name_(0),
		lmp_pal_subversion_(0),
		le_data_packet_length_(27),
		num_le_data_packets_(15),
		le_white_list_size_(15),
		le_resolving_list_size_(15) {
		std::string properties_raw;

		ASSERT(Address::FromString("BB:BB:BB:BB:BB:AD", address_));