Merge "Remove unused ble_addr functions" into main am: 50885c2513 am: b9384d06a8 (d9a1566a) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/btm/btm_ble_addr.cc

+0 −47

Original line number	Original line	Diff line number	Diff line
	@@ -40,7 +40,6 @@
	#include "stack/include/acl_api.h"		#include "stack/include/acl_api.h"
	#include "stack/include/bt_octets.h"		#include "stack/include/bt_octets.h"
	#include "stack/include/btm_ble_privacy.h"		#include "stack/include/btm_ble_privacy.h"
	#include "stack/include/btm_ble_sec_api.h"
	#include "types/ble_address_with_type.h"		#include "types/ble_address_with_type.h"
	#include "types/raw_address.h"		#include "types/raw_address.h"

	@@ -48,52 +47,6 @@ using namespace bluetooth;

	extern tBTM_CB btm_cb;		extern tBTM_CB btm_cb;

	/* This function generates Resolvable Private Address (RPA) from Identity
	* Resolving Key \|irk\| and \|random\|*/
	static RawAddress generate_rpa_from_irk_and_rand(const Octet16& irk,
	BT_OCTET8 random) {
	random[2] &= (~BLE_RESOLVE_ADDR_MASK);
	random[2] \|= BLE_RESOLVE_ADDR_MSB;

	RawAddress address;
	address.address[2] = random[0];
	address.address[1] = random[1];
	address.address[0] = random[2];

	/* encrypt with IRK */
	Octet16 r{};
	r[0] = random[0];
	r[1] = random[1];
	r[2] = random[2];
	Octet16 p = crypto_toolbox::aes_128(irk, r);

	/* set hash to be LSB of rpAddress */
	address.address[5] = p[0];
	address.address[4] = p[1];
	address.address[3] = p[2];
	return address;
	}

	/** This function is called when random address for local controller was
	* generated */
	void btm_gen_resolve_paddr_low(const RawAddress& address) {
	/* when GD advertising and scanning modules are enabled, set random address
	* via address manager in GD */
	log::info("GD advertising and scanning modules are enabled, skip");
	}

	/** This function generate a resolvable private address using local IRK */
	void btm_gen_resolvable_private_addr(
	base::Callback<void(const RawAddress&)> cb) {
	/* generate 3B rand as BD LSB, SRK with it, get BD MSB */
	btsnd_hcic_ble_rand(base::Bind(
	[](base::Callback<void(const RawAddress&)> cb, BT_OCTET8 random) {
	const Octet16& irk = BTM_GetDeviceIDRoot();
	cb.Run(generate_rpa_from_irk_and_rand(irk, random));
	},
	std::move(cb)));
	}

	/*******************************************************************************		/*******************************************************************************
	* Utility functions for Random address resolving		* Utility functions for Random address resolving
	******************************************************************************/		******************************************************************************/

system/stack/btm/btm_ble_gap.cc

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -959,7 +959,6 @@ bool BTM_BleConfigPrivacy(bool privacy_mode) {
	/* always set host random address, used when privacy 1.1 or priavcy 1.2 is		/* always set host random address, used when privacy 1.1 or priavcy 1.2 is
	* disabled */		* disabled */
	btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;		btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type = BLE_ADDR_RANDOM;
	btm_gen_resolvable_private_addr(base::Bind(&btm_gen_resolve_paddr_low));

	/* 4.2 controller only allow privacy 1.2 or mixed mode, resolvable private		/* 4.2 controller only allow privacy 1.2 or mixed mode, resolvable private
	* address in controller */		* address in controller */

system/stack/btm/btm_ble_int.h

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -51,11 +51,7 @@ void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy);
	void btm_ble_update_mode_operation(uint8_t link_role, const RawAddress* bda,		void btm_ble_update_mode_operation(uint8_t link_role, const RawAddress* bda,
	tHCI_STATUS status);		tHCI_STATUS status);
	/* BLE address management */		/* BLE address management */
	void btm_gen_resolvable_private_addr(
	base::Callback<void(const RawAddress& rpa)> cb);

	tBTM_SEC_DEV_REC* btm_ble_resolve_random_addr(const RawAddress& random_bda);		tBTM_SEC_DEV_REC* btm_ble_resolve_random_addr(const RawAddress& random_bda);
	void btm_gen_resolve_paddr_low(const RawAddress& address);

	void btm_ble_batchscan_init(void);		void btm_ble_batchscan_init(void);
	void btm_ble_adv_filter_init(void);		void btm_ble_adv_filter_init(void);

system/stack/btm/btm_ble_sec.cc

+0 −5

Original line number	Original line	Diff line number	Diff line
	@@ -1886,11 +1886,6 @@ static void btm_ble_reset_id_impl(const Octet16& rand1, const Octet16& rand2) {

	btm_notify_new_key(BTM_BLE_KEY_TYPE_ID);		btm_notify_new_key(BTM_BLE_KEY_TYPE_ID);

	/* if privacy is enabled, new RPA should be calculated */
	if (btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE) {
	btm_gen_resolvable_private_addr(base::Bind(&btm_gen_resolve_paddr_low));
	}

	/* proceed generate ER */		/* proceed generate ER */
	btm_sec_cb.devcb.ble_encryption_key_value = rand2;		btm_sec_cb.devcb.ble_encryption_key_value = rand2;
	btm_notify_new_key(BTM_BLE_KEY_TYPE_ER);		btm_notify_new_key(BTM_BLE_KEY_TYPE_ER);

system/test/mock/mock_stack_btm_ble_addr.cc

+0 −11

Original line number	Original line	Diff line number	Diff line
	@@ -37,8 +37,6 @@ namespace mock {
	namespace stack_btm_ble_addr {		namespace stack_btm_ble_addr {

	// Function state capture and return values, if needed		// Function state capture and return values, if needed
	struct btm_gen_resolve_paddr_low btm_gen_resolve_paddr_low;
	struct btm_gen_resolvable_private_addr btm_gen_resolvable_private_addr;
	struct btm_ble_init_pseudo_addr btm_ble_init_pseudo_addr;		struct btm_ble_init_pseudo_addr btm_ble_init_pseudo_addr;
	struct btm_ble_addr_resolvable btm_ble_addr_resolvable;		struct btm_ble_addr_resolvable btm_ble_addr_resolvable;
	struct btm_ble_resolve_random_addr btm_ble_resolve_random_addr;		struct btm_ble_resolve_random_addr btm_ble_resolve_random_addr;
	@@ -54,15 +52,6 @@ struct btm_ble_refresh_peer_resolvable_private_addr
	} // namespace test		} // namespace test

	// Mocked functions, if any		// Mocked functions, if any
	void btm_gen_resolve_paddr_low(const RawAddress& address) {
	inc_func_call_count(__func__);
	test::mock::stack_btm_ble_addr::btm_gen_resolve_paddr_low(address);
	}
	void btm_gen_resolvable_private_addr(
	base::Callback<void(const RawAddress&)> cb) {
	inc_func_call_count(__func__);
	test::mock::stack_btm_ble_addr::btm_gen_resolvable_private_addr(cb);
	}
	bool btm_ble_init_pseudo_addr(tBTM_SEC_DEV_REC* p_dev_rec,		bool btm_ble_init_pseudo_addr(tBTM_SEC_DEV_REC* p_dev_rec,
	const RawAddress& new_pseudo_addr) {		const RawAddress& new_pseudo_addr) {
	inc_func_call_count(__func__);		inc_func_call_count(__func__);