Merge changes I8b3c9cd4,Iedb0a81a,If7612988,I25f7c702,I23eb6baa, ... am: 5602109694 (d77f4bce) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/acl/btm_ble_connection_establishment.cc

+1 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include "stack/gatt/connection_manager.h"
		#include "stack/include/acl_api.h"
		#include "stack/include/ble_acl_interface.h"
		#include "stack/include/ble_hci_link_interface.h"
		#include "stack/include/hcimsgs.h"
		#include "stack/include/l2cap_hci_link_interface.h"

system/stack/btm/btm_ble_addr.cc

+9 −0

Original line number	Diff line number	Diff line
		@@ -37,6 +37,8 @@
		#include "stack/crypto_toolbox/crypto_toolbox.h"
		#include "stack/include/acl_api.h"

		void btm_ble_set_random_address(const RawAddress& random_bda);

		/* This function generates Resolvable Private Address (RPA) from Identity
		* Resolving Key \|irk\| and \|random\|*/
		RawAddress generate_rpa_from_irk_and_rand(const Octet16& irk,
		@@ -59,6 +61,13 @@ RawAddress generate_rpa_from_irk_and_rand(const Octet16& irk,
		return address;
		}

		static void btm_ble_refresh_raddr_timer_timeout(UNUSED_ATTR void* data) {
		if (btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_RANDOM) {
		/* refresh the random addr */
		btm_gen_resolvable_private_addr(base::Bind(&btm_gen_resolve_paddr_low));
		}
		}

		/** This function is called when random address for local controller was
		* generated */
		void btm_gen_resolve_paddr_low(const RawAddress& address) {

system/stack/btm/btm_ble_gap.cc

+6 −7

Original line number	Diff line number	Diff line
		@@ -55,6 +55,12 @@ extern tBTM_CB btm_cb;
		extern void btm_inq_remote_name_timer_timeout(void* data);
		extern bool btm_ble_init_pseudo_addr(tBTM_SEC_DEV_REC* p_dev_rec,
		const RawAddress& new_pseudo_addr);
		extern bool btm_identity_addr_to_random_pseudo(RawAddress* bd_addr,
		uint8_t* p_addr_type,
		bool refresh);
		extern void btm_ble_batchscan_init(void);
		extern void btm_ble_adv_filter_init(void);
		extern void btm_clear_all_pending_le_entry(void);

		#define BTM_EXT_BLE_RMT_NAME_TIMEOUT_MS (30 * 1000)
		#define MIN_ADV_LENGTH 2
		@@ -2163,13 +2169,6 @@ static void btm_ble_observer_timer_timeout(UNUSED_ATTR void* data) {
		btm_ble_stop_observe();
		}

		void btm_ble_refresh_raddr_timer_timeout(UNUSED_ATTR void* data) {
		if (btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type == BLE_ADDR_RANDOM) {
		/* refresh the random addr */
		btm_gen_resolvable_private_addr(base::Bind(&btm_gen_resolve_paddr_low));
		}
		}

		/*******************************************************************************
		*
		* Function btm_ble_read_remote_features_complete

system/stack/btm/btm_ble_int.h

+0 −31

Original line number	Diff line number	Diff line
		@@ -35,26 +35,16 @@
		#include "hcidefs.h"
		#include "smp_api.h"

		extern void btm_ble_refresh_raddr_timer_timeout(void* data);
		extern void btm_ble_process_periodic_adv_sync_est_evt(uint8_t len, uint8_t* p);
		extern void btm_ble_process_periodic_adv_pkt(uint8_t len, uint8_t* p);
		extern void btm_ble_process_periodic_adv_sync_lost_evt(uint8_t len, uint8_t* p);
		extern tBTM_STATUS btm_ble_read_remote_name(const RawAddress& remote_bda,
		tBTM_CMPL_CB* p_cb);
		extern bool btm_ble_cancel_remote_name(const RawAddress& remote_bda);

		extern tBTM_STATUS btm_ble_set_discoverability(uint16_t combined_mode);
		extern tBTM_STATUS btm_ble_set_connectability(uint16_t combined_mode);
		extern void btm_send_hci_set_scan_params(uint8_t scan_type, uint16_t scan_int,
		uint16_t scan_win,
		uint8_t addr_type_own,
		uint8_t scan_filter_policy);
		extern tBTM_STATUS btm_ble_start_inquiry(uint8_t duration);
		extern void btm_ble_stop_scan(void);
		extern void btm_clear_all_pending_le_entry(void);

		extern void btm_ble_stop_scan();
		extern void btm_ble_stop_inquiry(void);
		extern void btm_ble_init(void);
		extern void btm_ble_connected(const RawAddress& bda, uint16_t handle,
		uint8_t enc_mode, uint8_t role,
		@@ -63,11 +53,9 @@ extern void btm_ble_connected_from_address_with_type(
		const tBLE_BD_ADDR& address_with_type, uint16_t handle, uint8_t enc_mode,
		uint8_t role, bool addr_matched);

		extern void btm_ble_write_adv_enable_complete(uint8_t* p);
		extern tBTM_STATUS btm_ble_start_adv(void);
		extern tBTM_STATUS btm_ble_stop_adv(void);
		extern tBTM_STATUS btm_ble_start_scan(void);
		extern void btm_ble_create_ll_conn_complete(uint8_t status);

		/* LE security function from btm_sec.cc */
		extern void btm_ble_link_sec_check(const RawAddress& bd_addr,
		@@ -80,8 +68,6 @@ extern uint8_t btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr,
		extern tBTM_STATUS btm_ble_set_encryption(const RawAddress& bd_addr,
		tBTM_BLE_SEC_ACT sec_act,
		uint8_t link_role);
		extern void btm_ble_ltk_request(uint16_t handle, uint8_t rand[8],
		uint16_t ediv);
		extern tBTM_STATUS btm_ble_start_encrypt(const RawAddress& bda, bool use_stk,
		Octet16* p_stk);
		extern void btm_ble_link_encrypted(const RawAddress& bd_addr,
		@@ -97,10 +83,6 @@ extern bool btm_get_local_div(const RawAddress& bd_addr, uint16_t* p_div);
		extern bool btm_ble_get_enc_key_type(const RawAddress& bd_addr,
		uint8_t* p_key_types);

		extern void btm_ble_test_command_complete(uint8_t* p);
		extern void btm_ble_rand_enc_complete(uint8_t* p, uint16_t op_code,
		tBTM_RAND_ENC_CB* p_enc_cplt_cback);

		extern void btm_sec_save_le_key(const RawAddress& bd_addr,
		tBTM_LE_KEY_TYPE key_type,
		tBTM_LE_KEY_VALUE* p_keys,
		@@ -132,31 +114,18 @@ extern uint64_t btm_get_next_private_addrress_interval_ms();

		/* privacy function */
		/* BLE address mapping with CS feature */
		extern bool btm_identity_addr_to_random_pseudo(RawAddress* bd_addr,
		uint8_t* p_addr_type,
		bool refresh);
		extern bool btm_identity_addr_to_random_pseudo_from_address_with_type(
		tBLE_BD_ADDR* address_with_type, bool refresh);
		extern bool btm_random_pseudo_to_identity_addr(RawAddress* random_pseudo,
		uint8_t* p_identity_addr_type);
		extern void btm_ble_refresh_peer_resolvable_private_addr(
		const RawAddress& pseudo_bda, const RawAddress& rra,
		tBTM_SEC_BLE::tADDRESS_TYPE type);
		extern void btm_ble_read_resolving_list_entry_complete(uint8_t* p,
		uint16_t evt_len);
		extern bool btm_ble_read_resolving_list_entry(tBTM_SEC_DEV_REC* p_dev_rec);

		extern void btm_ble_create_conn_cancel_complete(uint8_t* p);
		extern bool btm_ble_addr_resolvable(const RawAddress& rpa,
		tBTM_SEC_DEV_REC* p_dev_rec);

		extern bool btm_ble_resolving_list_load_dev(tBTM_SEC_DEV_REC* p_dev_rec);
		extern void btm_ble_resolving_list_remove_dev(tBTM_SEC_DEV_REC* p_dev_rec);
		extern void btm_ble_remove_resolving_list_entry_complete(uint8_t* p,
		uint16_t evt_len);
		extern void btm_ble_add_resolving_list_entry_complete(uint8_t* p,
		uint16_t evt_len);
		extern void btm_ble_clear_resolving_list_complete(uint8_t* p, uint16_t evt_len);
		extern void btm_ble_enable_resolving_list(uint8_t);
		extern bool btm_ble_disable_resolving_list(uint8_t rl_mask, bool to_resume);
		extern void btm_ble_enable_resolving_list_for_platform(uint8_t rl_mask);

system/stack/btm/btm_ble_privacy.cc

+17 −30

Original line number	Diff line number	Diff line
		@@ -63,7 +63,7 @@
		* Returns void
		*
		******************************************************************************/
		void btm_ble_enq_resolving_list_pending(const RawAddress& pseudo_bda,
		static void btm_ble_enq_resolving_list_pending(const RawAddress& pseudo_bda,
		uint8_t op_code) {
		tBTM_BLE_RESOLVE_Q* p_q = &btm_cb.ble_ctr_cb.resolving_list_pend_q;

		@@ -85,8 +85,8 @@ void btm_ble_enq_resolving_list_pending(const RawAddress& pseudo_bda,
		* Returns void
		*
		******************************************************************************/
		bool btm_ble_brcm_find_resolving_pending_entry(const RawAddress& pseudo_addr,
		uint8_t action) {
		static bool btm_ble_brcm_find_resolving_pending_entry(
		const RawAddress& pseudo_addr, uint8_t action) {
		tBTM_BLE_RESOLVE_Q* p_q = &btm_cb.ble_ctr_cb.resolving_list_pend_q;

		for (uint8_t i = p_q->q_pending; i != p_q->q_next;) {
		@@ -112,7 +112,7 @@ bool btm_ble_brcm_find_resolving_pending_entry(const RawAddress& pseudo_addr,
		* Returns void
		*
		******************************************************************************/
		bool btm_ble_deq_resolving_pending(RawAddress& pseudo_addr) {
		static bool btm_ble_deq_resolving_pending(RawAddress& pseudo_addr) {
		tBTM_BLE_RESOLVE_Q* p_q = &btm_cb.ble_ctr_cb.resolving_list_pend_q;

		if (p_q->q_next != p_q->q_pending) {
		@@ -136,7 +136,7 @@ bool btm_ble_deq_resolving_pending(RawAddress& pseudo_addr) {
		* Returns none
		*
		******************************************************************************/
		void btm_ble_clear_irk_index(uint8_t index) {
		static void btm_ble_clear_irk_index(uint8_t index) {
		uint8_t byte;
		uint8_t bit;

		@@ -156,7 +156,7 @@ void btm_ble_clear_irk_index(uint8_t index) {
		* Returns index from 0 ~ max (127 default)
		*
		******************************************************************************/
		uint8_t btm_ble_find_irk_index(void) {
		static uint8_t btm_ble_find_irk_index(void) {
		uint8_t i = 0;
		uint8_t byte;
		uint8_t bit;
		@@ -185,7 +185,8 @@ uint8_t btm_ble_find_irk_index(void) {
		* Returns void
		*
		******************************************************************************/
		void btm_ble_update_resolving_list(const RawAddress& pseudo_bda, bool add) {
		static void btm_ble_update_resolving_list(const RawAddress& pseudo_bda,
		bool add) {
		tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(pseudo_bda);
		if (p_dev_rec == NULL) return;

		@@ -203,7 +204,7 @@ void btm_ble_update_resolving_list(const RawAddress& pseudo_bda, bool add) {
		}
		}

		bool clear_resolving_list_bit(void* data, void* context) {
		static bool clear_resolving_list_bit(void* data, void* context) {
		tBTM_SEC_DEV_REC* p_dev_rec = static_cast<tBTM_SEC_DEV_REC*>(data);
		p_dev_rec->ble.in_controller_list &= ~BTM_RESOLVING_LIST_BIT;
		return true;
		@@ -378,7 +379,7 @@ void btm_ble_read_resolving_list_entry_complete(uint8_t* p, uint16_t evt_len) {
		* Returns void
		*
		******************************************************************************/
		void btm_ble_resolving_list_vsc_op_cmpl(tBTM_VSC_CMPL* p_params) {
		static void btm_ble_resolving_list_vsc_op_cmpl(tBTM_VSC_CMPL* p_params) {
		uint8_t *p = p_params->p_param_buf, op_subcode;
		uint16_t evt_len = p_params->param_len;

		@@ -513,7 +514,7 @@ bool btm_ble_read_resolving_list_entry(tBTM_SEC_DEV_REC* p_dev_rec) {
		* Returns true if suspended; false otherwise
		*
		******************************************************************************/
		bool btm_ble_suspend_resolving_list_activity(void) {
		static bool btm_ble_suspend_resolving_list_activity(void) {
		tBTM_BLE_CB* p_ble_cb = &btm_cb.ble_ctr_cb;

		/* if resolving list is not enabled, do not need to terminate any activity */
		@@ -557,7 +558,7 @@ bool btm_ble_suspend_resolving_list_activity(void) {
		* Returns none
		*
		******************************************************************************/
		void btm_ble_resume_resolving_list_activity(void) {
		static void btm_ble_resume_resolving_list_activity(void) {
		tBTM_BLE_CB* p_ble_cb = &btm_cb.ble_ctr_cb;

		if (p_ble_cb->suspended_rl_state & BTM_BLE_RL_ADV) btm_ble_start_adv();
		@@ -586,7 +587,7 @@ void btm_ble_resume_resolving_list_activity(void) {
		* Parameters enable: enable or disable the RRA offloading feature
		*
		******************************************************************************/
		void btm_ble_vendor_enable_irk_feature(bool enable) {
		static void btm_ble_vendor_enable_irk_feature(bool enable) {
		uint8_t param[20], *p;

		p = param;
		@@ -609,7 +610,7 @@ void btm_ble_vendor_enable_irk_feature(bool enable) {
		* Returns none
		*
		******************************************************************************/
		bool btm_ble_exe_disable_resolving_list(void) {
		static bool btm_ble_exe_disable_resolving_list(void) {
		if (!btm_ble_suspend_resolving_list_activity()) return false;

		if (!controller_get_interface()->supports_ble_privacy())
		@@ -629,7 +630,7 @@ bool btm_ble_exe_disable_resolving_list(void) {
		* Returns none
		*
		******************************************************************************/
		void btm_ble_exe_enable_resolving_list(void) {
		static void btm_ble_exe_enable_resolving_list(void) {
		if (!btm_ble_suspend_resolving_list_activity()) return;

		if (!controller_get_interface()->supports_ble_privacy())
		@@ -831,21 +832,7 @@ void btm_ble_enable_resolving_list(uint8_t rl_mask) {
		}
		}

		/*******************************************************************************
		*
		* Function btm_ble_resolving_list_empty
		*
		* Description check to see if resoving list is empty or not
		*
		* Returns true: empty; false non-empty
		*
		******************************************************************************/
		bool btm_ble_resolving_list_empty(void) {
		return (controller_get_interface()->get_ble_resolving_list_max_size() ==
		btm_cb.ble_ctr_cb.resolving_list_avail_size);
		}

		bool is_on_resolving_list(void* data, void* context) {
		static bool is_on_resolving_list(void* data, void* context) {
		tBTM_SEC_DEV_REC* p_dev = static_cast<tBTM_SEC_DEV_REC*>(data);
		if ((p_dev->ble.in_controller_list & BTM_RESOLVING_LIST_BIT) &&
		(p_dev->ble.in_controller_list & BTM_WHITE_LIST_BIT))