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

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

+70 −0

Original line number	Original line	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::READ_REMOTE_VERSION_INFORMATION, HciReadRemoteVersionInformation);
	SET_HANDLER(OpCode::LE_CONNECTION_UPDATE, HciLeConnectionUpdate);		SET_HANDLER(OpCode::LE_CONNECTION_UPDATE, HciLeConnectionUpdate);
	SET_HANDLER(OpCode::LE_START_ENCRYPTION, HciLeStartEncryption);		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		// Testing Commands
	SET_HANDLER(OpCode::READ_LOOPBACK_MODE, HciReadLoopbackMode);		SET_HANDLER(OpCode::READ_LOOPBACK_MODE, HciReadLoopbackMode);
	SET_HANDLER(OpCode::WRITE_LOOPBACK_MODE, HciWriteLoopbackMode);		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);		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,		void DualModeController::HciLeReadRemoteUsedFeaturesRsp(uint16_t handle,
	uint64_t features) {		uint64_t features) {

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

+12 −0

Original line number	Original line	Diff line number	Diff line
	@@ -380,6 +380,18 @@ class DualModeController : public Device {
	// 7.8.27		// 7.8.27
	void HciLeReadSupportedStates(packets::PacketView<true> args);		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		// Vendor-specific Commands

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

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

+53 −0

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

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

	void LinkLayerController::LeWhiteListAddDevice(Address addr, uint8_t addr_type) {		void LinkLayerController::LeWhiteListAddDevice(Address addr, uint8_t addr_type) {
	std::tuple<Address, uint8_t> new_tuple = std::make_tuple(addr, addr_type);		std::tuple<Address, uint8_t> new_tuple = std::make_tuple(addr, addr_type);
	for (auto dev : le_white_list_) {		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);		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) {		void LinkLayerController::LeWhiteListRemoveDevice(Address addr, uint8_t addr_type) {
	// TODO: Add checks to see if advertising, scanning, or a connection request		// TODO: Add checks to see if advertising, scanning, or a connection request
	// with the white list is ongoing.		// 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) {		bool LinkLayerController::LeWhiteListContainsDevice(Address addr, uint8_t addr_type) {
	std::tuple<Address, uint8_t> sought_tuple = std::make_tuple(addr, 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++) {		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;		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() {		bool LinkLayerController::LeWhiteListFull() {
	return le_white_list_.size() >= properties_.GetLeWhiteListSize();		return le_white_list_.size() >= properties_.GetLeWhiteListSize();
	}		}

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

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

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

+13 −0

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

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

	LinkLayerController(const DeviceProperties& properties) : properties_(properties) {}		LinkLayerController(const DeviceProperties& properties) : properties_(properties) {}
	hci::Status SendCommandToRemoteByAddress(hci::OpCode opcode, packets::PacketView<true> args, const Address& remote,		hci::Status SendCommandToRemoteByAddress(hci::OpCode opcode, packets::PacketView<true> args, const Address& remote,
	bool use_public_address);		bool use_public_address);
	@@ -118,6 +120,14 @@ class LinkLayerController {
	void LeWhiteListRemoveDevice(Address addr, uint8_t addr_type);		void LeWhiteListRemoveDevice(Address addr, uint8_t addr_type);
	bool LeWhiteListContainsDevice(Address addr, uint8_t addr_type);		bool LeWhiteListContainsDevice(Address addr, uint8_t addr_type);
	bool LeWhiteListFull();		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) {		hci::Status SetLeAdvertisingEnable(uint8_t le_advertising_enable) {
	le_advertising_enable_ = le_advertising_enable;		le_advertising_enable_ = le_advertising_enable;
	@@ -272,6 +282,9 @@ class LinkLayerController {
	std::vector<uint8_t> le_event_mask_;		std::vector<uint8_t> le_event_mask_;

	std::vector<std::tuple<Address, uint8_t>> le_white_list_;		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};		uint8_t le_advertising_enable_{false};
	std::chrono::steady_clock::time_point last_le_advertisement_;		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	Original line	Diff line number	Diff line
	@@ -45,10 +45,19 @@ bool ParseUint16t(base::StringPiece value, uint16_t* field) {
	namespace test_vendor_lib {		namespace test_vendor_lib {

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

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