Merge "[Invisalign2] define tBTM_SP_EVT and tBTM_LE_EVT as enums" into main... (36b9f51b) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/dm/bta_dm_sec.cc

+32 −50

Original line number	Original line	Diff line number	Diff line
	@@ -16,8 +16,6 @@

	#define LOG_TAG "bt_bta_dm_sec"		#define LOG_TAG "bt_bta_dm_sec"

	#include <base/logging.h>

	#include <cstdint>		#include <cstdint>

	#include "bta/dm/bta_dm_act.h"		#include "bta/dm/bta_dm_act.h"
	@@ -82,13 +80,12 @@ void btm_sec_on_hw_on() {
	void bta_dm_ble_sirk_sec_cb_register(tBTA_DM_SEC_CBACK* p_cback) {		void bta_dm_ble_sirk_sec_cb_register(tBTA_DM_SEC_CBACK* p_cback) {
	/* Save the callback to be called when a request of member validation will be		/* Save the callback to be called when a request of member validation will be
	* needed. */		* needed. */
	LOG_DEBUG("");
	bta_dm_sec_cb.p_sec_sirk_cback = p_cback;		bta_dm_sec_cb.p_sec_sirk_cback = p_cback;
	}		}

	void bta_dm_ble_sirk_confirm_device_reply(const RawAddress& bd_addr,		void bta_dm_ble_sirk_confirm_device_reply(const RawAddress& bd_addr,
	bool accept) {		bool accept) {
	LOG_DEBUG("");		LOG_DEBUG("addr:%s", ADDRESS_TO_LOGGABLE_CSTR(bd_addr));
	get_btm_client_interface().security.BTM_BleSirkConfirmDeviceReply(		get_btm_client_interface().security.BTM_BleSirkConfirmDeviceReply(
	bd_addr, accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED);		bd_addr, accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED);
	}		}
	@@ -140,8 +137,7 @@ void bta_dm_add_device(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg) {
	msg->bd_addr, dc, msg->bd_name, nullptr, p_lc, msg->key_type,		msg->bd_addr, dc, msg->bd_name, nullptr, p_lc, msg->key_type,
	msg->pin_length);		msg->pin_length);
	if (!add_result) {		if (!add_result) {
	LOG(ERROR) << "BTA_DM: Error adding device "		LOG_ERROR("Error adding device:%s", ADDRESS_TO_LOGGABLE_CSTR(msg->bd_addr));
	<< ADDRESS_TO_LOGGABLE_STR(msg->bd_addr);
	}		}
	}		}

	@@ -189,7 +185,7 @@ void bta_dm_bond_cancel(const RawAddress& bd_addr) {
	tBTM_STATUS status;		tBTM_STATUS status;
	tBTA_DM_SEC sec_event;		tBTA_DM_SEC sec_event;

	LOG_VERBOSE(" bta_dm_bond_cancel ");		LOG_DEBUG("addr:%s", ADDRESS_TO_LOGGABLE_CSTR(bd_addr));

	status = get_btm_client_interface().security.BTM_SecBondCancel(bd_addr);		status = get_btm_client_interface().security.BTM_SecBondCancel(bd_addr);

	@@ -311,7 +307,8 @@ static uint8_t bta_dm_pin_cback(const RawAddress& bd_addr, DEV_CLASS dev_class,
	BTM_CMD_STARTED)		BTM_CMD_STARTED)
	return BTM_CMD_STARTED;		return BTM_CMD_STARTED;

	LOG_WARN(" bta_dm_pin_cback() -> Failed to start Remote Name Request ");		LOG_WARN("Failed to start Remote Name Request, addr:%s",
			ADDRESS_TO_LOGGABLE_CSTR(bd_addr));
	}		}

	tBTA_DM_SEC sec_event = {.pin_req = {		tBTA_DM_SEC sec_event = {.pin_req = {
	@@ -413,9 +410,7 @@ static void bta_dm_authentication_complete_cback(
	case HCI_ERR_KEY_MISSING:		case HCI_ERR_KEY_MISSING:
	case HCI_ERR_HOST_REJECT_SECURITY:		case HCI_ERR_HOST_REJECT_SECURITY:
	case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:		case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
	LOG_WARN(		LOG_WARN("authentication failed entry:%s, reason:%s",
	"Deleting device record as authentication failed entry:%s "
	"reason:%s",
	ADDRESS_TO_LOGGABLE_CSTR(bd_addr),		ADDRESS_TO_LOGGABLE_CSTR(bd_addr),
	hci_reason_code_text(reason).c_str());		hci_reason_code_text(reason).c_str());
	break;		break;
	@@ -441,7 +436,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event,
	tBTA_DM_SEC sec_event = {};		tBTA_DM_SEC sec_event = {};
	tBTA_DM_SEC_EVT pin_evt = BTA_DM_SP_KEY_NOTIF_EVT;		tBTA_DM_SEC_EVT pin_evt = BTA_DM_SP_KEY_NOTIF_EVT;

	LOG_VERBOSE("bta_dm_sp_cback: %d", event);		LOG_VERBOSE("event:%s", sp_evt_to_text(event).c_str());
	if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;		if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;

	bool sp_rmt_result = false;		bool sp_rmt_result = false;
	@@ -534,8 +529,8 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event,
	p_data->key_notif.bd_addr, bta_dm_pinname_cback,		p_data->key_notif.bd_addr, bta_dm_pinname_cback,
	BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)		BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)
	return BTM_CMD_STARTED;		return BTM_CMD_STARTED;
	LOG_WARN(		LOG_WARN("Failed to start Remote Name Request, addr:%s",
	" bta_dm_sp_cback() -> Failed to start Remote Name Request ");		ADDRESS_TO_LOGGABLE_CSTR(p_data->key_notif.bd_addr));
	} else {		} else {
	sec_event.key_notif.bd_addr = p_data->key_notif.bd_addr;		sec_event.key_notif.bd_addr = p_data->key_notif.bd_addr;
	sec_event.key_notif.dev_class = p_data->key_notif.dev_class;		sec_event.key_notif.dev_class = p_data->key_notif.dev_class;
	@@ -564,7 +559,7 @@ static tBTM_STATUS bta_dm_sp_cback(tBTM_SP_EVT event,
	#ifdef BTIF_DM_OOB_TEST		#ifdef BTIF_DM_OOB_TEST
	sp_rmt_result = btif_dm_proc_rmt_oob(p_data->rmt_oob.bd_addr, &c, &r);		sp_rmt_result = btif_dm_proc_rmt_oob(p_data->rmt_oob.bd_addr, &c, &r);
	#endif		#endif
	LOG_VERBOSE("bta_dm_ci_rmt_oob: result=%d", sp_rmt_result);		LOG_VERBOSE("result=%d", sp_rmt_result);
	bta_dm_ci_rmt_oob(sp_rmt_result, p_data->rmt_oob.bd_addr, c, r);		bta_dm_ci_rmt_oob(sp_rmt_result, p_data->rmt_oob.bd_addr, c, r);
	break;		break;
	}		}
	@@ -620,8 +615,8 @@ static void bta_dm_remove_sec_dev_entry(const RawAddress& remote_bd_addr) {
	BT_TRANSPORT_LE) \|\|		BT_TRANSPORT_LE) \|\|
	get_btm_client_interface().peer.BTM_IsAclConnectionUp(		get_btm_client_interface().peer.BTM_IsAclConnectionUp(
	remote_bd_addr, BT_TRANSPORT_BR_EDR)) {		remote_bd_addr, BT_TRANSPORT_BR_EDR)) {
	LOG_VERBOSE("%s ACL is not down. Schedule for Dev Removal when ACL closes",		LOG_DEBUG("ACL is not down. Schedule for Dev Removal when ACL closes:%s",
	__func__);		ADDRESS_TO_LOGGABLE_CSTR(remote_bd_addr));
	get_btm_client_interface().security.BTM_SecClearSecurityFlags(		get_btm_client_interface().security.BTM_SecClearSecurityFlags(
	remote_bd_addr);		remote_bd_addr);
	for (int i = 0; i < bta_dm_cb.device_list.count; i++) {		for (int i = 0; i < bta_dm_cb.device_list.count; i++) {
	@@ -718,6 +713,9 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
	tBTA_DM_SEC sec_event;		tBTA_DM_SEC sec_event;
	const char* p_name = NULL;		const char* p_name = NULL;

			LOG_DEBUG("addr:%s,event:%s", ADDRESS_TO_LOGGABLE_CSTR(bda),
			ble_evt_to_text(event).c_str());

	if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;		if (!bta_dm_sec_cb.p_sec_cback) return BTM_NOT_AUTHORIZED;

	memset(&sec_event, 0, sizeof(tBTA_DM_SEC));		memset(&sec_event, 0, sizeof(tBTA_DM_SEC));
	@@ -726,7 +724,7 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
	ble_io_req(bda, &p_data->io_req.io_cap, &p_data->io_req.oob_data,		ble_io_req(bda, &p_data->io_req.io_cap, &p_data->io_req.oob_data,
	&p_data->io_req.auth_req, &p_data->io_req.max_key_size,		&p_data->io_req.auth_req, &p_data->io_req.max_key_size,
	&p_data->io_req.init_keys, &p_data->io_req.resp_keys);		&p_data->io_req.init_keys, &p_data->io_req.resp_keys);
	LOG_VERBOSE("io mitm: %d oob_data:%d", p_data->io_req.auth_req,		LOG_INFO("io mitm:%d oob_data:%d", p_data->io_req.auth_req,
	p_data->io_req.oob_data);		p_data->io_req.oob_data);
	break;		break;

	@@ -822,9 +820,9 @@ static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
	// Bonded device failed to encrypt - to test this remove battery from		// Bonded device failed to encrypt - to test this remove battery from
	// HID device right after connection, but before encryption is		// HID device right after connection, but before encryption is
	// established		// established
	LOG(INFO) << __func__		LOG_WARN(
	<< ": bonded device disconnected when encrypting - no "		"bonded device disconnected when encrypting - no reason to "
	"reason to unbond";		"unbond");
	} else {		} else {
	/* delete this device entry from Sec Dev DB */		/* delete this device entry from Sec Dev DB */
	bta_dm_remove_sec_dev_entry(bda);		bta_dm_remove_sec_dev_entry(bda);
	@@ -873,47 +871,30 @@ void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
	device->p_encrypt_cback = nullptr;		device->p_encrypt_cback = nullptr;
	}		}

	tBTA_STATUS bta_status = BTA_SUCCESS;		LOG_DEBUG("Encrypted:%c, peer:%s transport:%s status:%s callback:%c",
	switch (result) {		result == BTM_SUCCESS ? 'T' : 'F',
	case BTM_SUCCESS:
	LOG_WARN("Encrypted link peer:%s transport:%s status:%s callback:%c",
	ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),		ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
	bt_transport_text(transport).c_str(),		bt_transport_text(transport).c_str(),
	btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');		btm_status_text(result).c_str(), (p_callback) ? 'T' : 'F');

			tBTA_STATUS bta_status = BTA_SUCCESS;
			switch (result) {
			case BTM_SUCCESS:
	break;		break;
	case BTM_WRONG_MODE:		case BTM_WRONG_MODE:
	LOG_WARN(
	"Unable to encrypt link peer:%s transport:%s status:%s callback:%c",
	ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
	bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
	(p_callback) ? 'T' : 'F');
	bta_status = BTA_WRONG_MODE;		bta_status = BTA_WRONG_MODE;
	break;		break;
	case BTM_NO_RESOURCES:		case BTM_NO_RESOURCES:
	LOG_WARN(
	"Unable to encrypt link peer:%s transport:%s status:%s callback:%c",
	ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
	bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
	(p_callback) ? 'T' : 'F');
	bta_status = BTA_NO_RESOURCES;		bta_status = BTA_NO_RESOURCES;
	break;		break;
	case BTM_BUSY:		case BTM_BUSY:
	LOG_WARN(
	"Unable to encrypt link peer:%s transport:%s status:%s callback:%c",
	ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
	bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
	(p_callback) ? 'T' : 'F');
	bta_status = BTA_BUSY;		bta_status = BTA_BUSY;
	break;		break;
	default:		default:
	LOG_ERROR(
	"Failed to encrypt link peer:%s transport:%s status:%s callback:%c",
	ADDRESS_TO_LOGGABLE_CSTR((*bd_addr)),
	bt_transport_text(transport).c_str(), btm_status_text(result).c_str(),
	(p_callback) ? 'T' : 'F');
	bta_status = BTA_FAILURE;		bta_status = BTA_FAILURE;
	break;		break;
	}		}

	if (p_callback) {		if (p_callback) {
	(p_callback)(bd_addr, transport, bta_status);		(p_callback)(bd_addr, transport, bta_status);
	}		}
	@@ -924,7 +905,8 @@ void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
	tBTA_DM_ENCRYPT_CBACK* p_callback,		tBTA_DM_ENCRYPT_CBACK* p_callback,
	tBTM_BLE_SEC_ACT sec_act) {		tBTM_BLE_SEC_ACT sec_act) {
	if (p_callback == nullptr) {		if (p_callback == nullptr) {
	LOG_ERROR("bta_dm_set_encryption callback is not provided");		LOG_ERROR("callback is not provided,addr:%s",
			ADDRESS_TO_LOGGABLE_CSTR(bd_addr));
	return;		return;
	}		}

system/stack/btm/btm_ble_sec.cc

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -1599,8 +1599,8 @@ tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr,
	* capability... */		* capability... */
	LOG_VERBOSE("btm_sec_cb.api.p_le_callback=0x%p",		LOG_VERBOSE("btm_sec_cb.api.p_le_callback=0x%p",
	btm_sec_cb.api.p_le_callback);		btm_sec_cb.api.p_le_callback);
	(*btm_sec_cb.api.p_le_callback)(event, bd_addr,		(*btm_sec_cb.api.p_le_callback)(static_cast<tBTM_LE_EVT>(event),
	(tBTM_LE_EVT_DATA*)p_data);		bd_addr, (tBTM_LE_EVT_DATA*)p_data);
	}		}

	if (event == SMP_COMPLT_EVT) {		if (event == SMP_COMPLT_EVT) {
	@@ -1677,8 +1677,8 @@ tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr,
	if (btm_sec_cb.api.p_le_callback) {		if (btm_sec_cb.api.p_le_callback) {
	LOG_VERBOSE("btm_sec_cb.api.p_le_callback=0x%p",		LOG_VERBOSE("btm_sec_cb.api.p_le_callback=0x%p",
	btm_sec_cb.api.p_le_callback);		btm_sec_cb.api.p_le_callback);
	(*btm_sec_cb.api.p_le_callback)(event, bd_addr,		(*btm_sec_cb.api.p_le_callback)(static_cast<tBTM_LE_EVT>(event),
	(tBTM_LE_EVT_DATA*)p_data);		bd_addr, (tBTM_LE_EVT_DATA*)p_data);
	}		}
	break;		break;

system/stack/btm/btm_sec.cc

+13 −13

Original line number	Original line	Diff line number	Diff line
	@@ -2675,8 +2675,8 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
	tBTM_SEC_DEV_REC* p_dev_rec;		tBTM_SEC_DEV_REC* p_dev_rec;

	p_bda = bda;		p_bda = bda;
	LOG_VERBOSE("BDA: %s, event: 0x%x, state: %s",		LOG_DEBUG("BDA:%s, event:%s, state:%s", ADDRESS_TO_LOGGABLE_CSTR(p_bda),
	ADDRESS_TO_LOGGABLE_CSTR(p_bda), event,		sp_evt_to_text(event).c_str(),
	tBTM_SEC_CB::btm_pair_state_descr(btm_sec_cb.pairing_state));		tBTM_SEC_CB::btm_pair_state_descr(btm_sec_cb.pairing_state));

	p_dev_rec = btm_find_dev(p_bda);		p_dev_rec = btm_find_dev(p_bda);
	@@ -2696,8 +2696,7 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,

	/* The device record must be allocated in the "IO cap exchange" step */		/* The device record must be allocated in the "IO cap exchange" step */
	evt_data.cfm_req.num_val = value;		evt_data.cfm_req.num_val = value;
	LOG_VERBOSE("BTM_SP_CFM_REQ_EVT: num_val: %u",		LOG_VERBOSE("num_val:%u", evt_data.cfm_req.num_val);
	evt_data.cfm_req.num_val);

	evt_data.cfm_req.just_works = true;		evt_data.cfm_req.just_works = true;

	@@ -2725,11 +2724,10 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
	}		}
	}		}

	LOG_VERBOSE(		LOG_VERBOSE("just_works:%d, io loc:%d, rmt:%d, auth loc:%d, rmt:%d",
	"btm_proc_sp_req_evt() just_works:%d, io loc:%d, rmt:%d, auth "
	"loc:%d, rmt:%d",
	evt_data.cfm_req.just_works, btm_sec_cb.devcb.loc_io_caps,		evt_data.cfm_req.just_works, btm_sec_cb.devcb.loc_io_caps,
	p_dev_rec->sec_rec.rmt_io_caps, btm_sec_cb.devcb.loc_auth_req,		p_dev_rec->sec_rec.rmt_io_caps,
			btm_sec_cb.devcb.loc_auth_req,
	p_dev_rec->sec_rec.rmt_auth_req);		p_dev_rec->sec_rec.rmt_auth_req);

	evt_data.cfm_req.loc_auth_req = btm_sec_cb.devcb.loc_auth_req;		evt_data.cfm_req.loc_auth_req = btm_sec_cb.devcb.loc_auth_req;
	@@ -2741,8 +2739,7 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
	case BTM_SP_KEY_NOTIF_EVT:		case BTM_SP_KEY_NOTIF_EVT:
	/* Passkey notification (other side is a keyboard) */		/* Passkey notification (other side is a keyboard) */
	evt_data.key_notif.passkey = value;		evt_data.key_notif.passkey = value;
	LOG_VERBOSE("BTM_SP_KEY_NOTIF_EVT: passkey: %u",		LOG_VERBOSE("passkey:%u", evt_data.key_notif.passkey);
	evt_data.key_notif.passkey);

	btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);		btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_WAIT_AUTH_COMPLETE);
	break;		break;
	@@ -2753,6 +2750,9 @@ void btm_proc_sp_req_evt(tBTM_SP_EVT event, const RawAddress bda,
	btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_KEY_ENTRY);		btm_sec_cb.change_pairing_state(BTM_PAIR_STATE_KEY_ENTRY);
	}		}
	break;		break;
			default:
			LOG_WARN("unhandled event:%s", sp_evt_to_text(event).c_str());
			break;
	}		}

	if (btm_sec_cb.api.p_sp_callback) {		if (btm_sec_cb.api.p_sp_callback) {

system/stack/btu/btu_hcif.cc

+8 −6

Original line number	Original line	Diff line number	Diff line
	@@ -31,7 +31,6 @@

	#include <base/functional/bind.h>		#include <base/functional/bind.h>
	#include <base/location.h>		#include <base/location.h>
	#include <base/logging.h>

	#include <cstdint>		#include <cstdint>

	@@ -1128,7 +1127,7 @@ static void btu_hcif_hdl_command_complete(uint16_t opcode, uint8_t* p,
	case HCI_BLE_CREATE_LL_CONN:		case HCI_BLE_CREATE_LL_CONN:
	case HCI_LE_EXTENDED_CREATE_CONNECTION:		case HCI_LE_EXTENDED_CREATE_CONNECTION:
	// No command complete event for those commands according to spec		// No command complete event for those commands according to spec
	LOG(ERROR) << "No command complete expected, but received!";		LOG_ERROR("No command complete expected, but received!");
	break;		break;

	case HCI_BLE_TRANSMITTER_TEST:		case HCI_BLE_TRANSMITTER_TEST:
	@@ -1459,6 +1458,9 @@ void btu_hcif_proc_sp_req_evt(tBTM_SP_EVT event, const uint8_t* p) {
	case BTM_SP_KEY_REQ_EVT:		case BTM_SP_KEY_REQ_EVT:
	// No value needed.		// No value needed.
	break;		break;
			default:
			LOG_WARN("unexpected event:%s", sp_evt_to_text(event).c_str());
			break;
	}		}
	btm_proc_sp_req_evt(event, bda, value);		btm_proc_sp_req_evt(event, bda, value);
	}		}
	@@ -1466,7 +1468,7 @@ void btu_hcif_create_conn_cancel_complete(const uint8_t* p, uint16_t evt_len) {
	uint8_t status;		uint8_t status;

	if (evt_len < 1 + BD_ADDR_LEN) {		if (evt_len < 1 + BD_ADDR_LEN) {
	LOG_ERROR("%s malformatted event packet, too short", __func__);		LOG_ERROR("malformatted event packet, too short");
	return;		return;
	}		}

	@@ -1496,7 +1498,7 @@ void btu_hcif_read_local_oob_complete(const uint8_t* p, uint16_t evt_len) {
	return;		return;

	err_out:		err_out:
	LOG_ERROR("%s: bogus event packet, too short", __func__);		LOG_ERROR("bogus event packet, too short");
	}		}

	/*******************************************************************************		/*******************************************************************************
	@@ -1662,7 +1664,7 @@ static void btu_ble_data_length_change_evt(uint8_t* p, uint16_t evt_len) {
	uint16_t rx_data_len;		uint16_t rx_data_len;

	if (!controller_get_interface()->SupportsBleDataPacketLengthExtension()) {		if (!controller_get_interface()->SupportsBleDataPacketLengthExtension()) {
	LOG_WARN("%s, request not supported", __func__);		LOG_WARN("request not supported");
	return;		return;
	}		}

	@@ -1688,7 +1690,7 @@ static void btu_ble_rc_param_req_evt(uint8_t* p, uint8_t len) {
	uint16_t int_min, int_max, latency, timeout;		uint16_t int_min, int_max, latency, timeout;

	if (len < 10) {		if (len < 10) {
	LOG(ERROR) << __func__ << "bogus event packet, too short";		LOG_ERROR("bogus event packet, too short");
	return;		return;
	}		}

system/stack/include/btm_sec_api_types.h

+75 −32

Original line number	Original line	Diff line number	Diff line
	@@ -173,7 +173,7 @@ typedef uint8_t tBTM_LINK_KEY_TYPE;
	* trusted services		* trusted services
	******************************************************************************/		******************************************************************************/

	enum {		typedef enum : uint8_t {
	BTM_SP_IO_REQ_EVT, /* received IO_CAPABILITY_REQUEST event */		BTM_SP_IO_REQ_EVT, /* received IO_CAPABILITY_REQUEST event */
	BTM_SP_IO_RSP_EVT, /* received IO_CAPABILITY_RESPONSE event */		BTM_SP_IO_RSP_EVT, /* received IO_CAPABILITY_RESPONSE event */
	BTM_SP_CFM_REQ_EVT, /* received USER_CONFIRMATION_REQUEST event */		BTM_SP_CFM_REQ_EVT, /* received USER_CONFIRMATION_REQUEST event */
	@@ -181,8 +181,21 @@ enum {
	BTM_SP_KEY_REQ_EVT, /* received USER_PASSKEY_REQUEST event */		BTM_SP_KEY_REQ_EVT, /* received USER_PASSKEY_REQUEST event */
	BTM_SP_LOC_OOB_EVT, /* received result for READ_LOCAL_OOB_DATA command */		BTM_SP_LOC_OOB_EVT, /* received result for READ_LOCAL_OOB_DATA command */
	BTM_SP_RMT_OOB_EVT, /* received REMOTE_OOB_DATA_REQUEST event */		BTM_SP_RMT_OOB_EVT, /* received REMOTE_OOB_DATA_REQUEST event */
	};		} tBTM_SP_EVT;
	typedef uint8_t tBTM_SP_EVT;
			inline std::string sp_evt_to_text(const tBTM_SP_EVT evt) {
			switch (evt) {
			CASE_RETURN_TEXT(BTM_SP_IO_REQ_EVT);
			CASE_RETURN_TEXT(BTM_SP_IO_RSP_EVT);
			CASE_RETURN_TEXT(BTM_SP_CFM_REQ_EVT);
			CASE_RETURN_TEXT(BTM_SP_KEY_NOTIF_EVT);
			CASE_RETURN_TEXT(BTM_SP_KEY_REQ_EVT);
			CASE_RETURN_TEXT(BTM_SP_LOC_OOB_EVT);
			CASE_RETURN_TEXT(BTM_SP_RMT_OOB_EVT);
			}

			return base::StringPrintf("UNKNOWN[%hhu]", evt);
			}

	enum : uint8_t {		enum : uint8_t {
	BTM_IO_CAP_OUT = 0, /* DisplayOnly */		BTM_IO_CAP_OUT = 0, /* DisplayOnly */
	@@ -372,35 +385,65 @@ typedef tBTM_SEC_CALLBACK tBTM_SEC_CALLBACK;
	*/		*/
	typedef void(tBTM_BOND_CANCEL_CMPL_CALLBACK)(tBTM_STATUS result);		typedef void(tBTM_BOND_CANCEL_CMPL_CALLBACK)(tBTM_STATUS result);

			typedef enum : uint8_t {
	/* LE related event and data structure */		/* LE related event and data structure */
	/* received IO_CAPABILITY_REQUEST event */		/* received IO_CAPABILITY_REQUEST event */
	#define BTM_LE_IO_REQ_EVT SMP_IO_CAP_REQ_EVT		BTM_LE_IO_REQ_EVT = SMP_IO_CAP_REQ_EVT,
	/* security request event */		/* security request event */
	#define BTM_LE_SEC_REQUEST_EVT SMP_SEC_REQUEST_EVT		BTM_LE_SEC_REQUEST_EVT = SMP_SEC_REQUEST_EVT,

	/* received USER_PASSKEY_NOTIFY event */		/* received USER_PASSKEY_NOTIFY event */
	#define BTM_LE_KEY_NOTIF_EVT SMP_PASSKEY_NOTIF_EVT		BTM_LE_KEY_NOTIF_EVT = SMP_PASSKEY_NOTIF_EVT,

	/* received USER_PASSKEY_REQUEST event */		/* received USER_PASSKEY_REQUEST event */
	#define BTM_LE_KEY_REQ_EVT SMP_PASSKEY_REQ_EVT		BTM_LE_KEY_REQ_EVT = SMP_PASSKEY_REQ_EVT,

	/* OOB data request event */		/* OOB data request event */
	#define BTM_LE_OOB_REQ_EVT SMP_OOB_REQ_EVT		BTM_LE_OOB_REQ_EVT = SMP_OOB_REQ_EVT,

	/* Numeric Comparison request event */		/* Numeric Comparison request event */
	#define BTM_LE_NC_REQ_EVT SMP_NC_REQ_EVT		BTM_LE_NC_REQ_EVT = SMP_NC_REQ_EVT,

	/* Peer keypress notification recd event */		/* Peer keypress notification recd event */
	#define BTM_LE_PR_KEYPR_NOT_EVT SMP_PEER_KEYPR_NOT_EVT		BTM_LE_PR_KEYPR_NOT_EVT = SMP_PEER_KEYPR_NOT_EVT,

	/* SC OOB request event (both local and peer OOB data) can be expected in		/* SC OOB request event (both local and peer OOB data) can be expected in
	* response */		* response */
	#define BTM_LE_SC_OOB_REQ_EVT SMP_SC_OOB_REQ_EVT		BTM_LE_SC_OOB_REQ_EVT = SMP_SC_OOB_REQ_EVT,

	/* SC OOB local data set is created (as result of SMP_CrLocScOobData(...)) */		/* SC OOB local data set is created (as result of SMP_CrLocScOobData(...)) */
	#define BTM_LE_SC_LOC_OOB_EVT SMP_SC_LOC_OOB_DATA_UP_EVT		BTM_LE_SC_LOC_OOB_EVT = SMP_SC_LOC_OOB_DATA_UP_EVT,
	/* SMP complete event */		/* SMP complete event */
	#define BTM_LE_COMPLT_EVT SMP_COMPLT_EVT		BTM_LE_COMPLT_EVT = SMP_COMPLT_EVT,
	#define BTM_LE_LAST_FROM_SMP SMP_BR_KEYS_REQ_EVT		BTM_LE_LAST_FROM_SMP = SMP_BR_KEYS_REQ_EVT,
	/* KEY update event */		/* KEY update event */
	#define BTM_LE_KEY_EVT (BTM_LE_LAST_FROM_SMP + 1)		BTM_LE_KEY_EVT = (BTM_LE_LAST_FROM_SMP + 1),
	#define BTM_LE_CONSENT_REQ_EVT SMP_CONSENT_REQ_EVT		BTM_LE_CONSENT_REQ_EVT = SMP_CONSENT_REQ_EVT,

	/* Identity address associate event */		/* Identity address associate event */
	#define BTM_LE_ADDR_ASSOC_EVT SMP_LE_ADDR_ASSOC_EVT		BTM_LE_ADDR_ASSOC_EVT = SMP_LE_ADDR_ASSOC_EVT,
	typedef uint8_t tBTM_LE_EVT;		} tBTM_LE_EVT;

			inline std::string ble_evt_to_text(const tBTM_LE_EVT evt) {
			switch (evt) {
			CASE_RETURN_TEXT(BTM_LE_IO_REQ_EVT);
			CASE_RETURN_TEXT(BTM_LE_SEC_REQUEST_EVT);
			CASE_RETURN_TEXT(BTM_LE_KEY_NOTIF_EVT);
			CASE_RETURN_TEXT(BTM_LE_KEY_REQ_EVT);
			CASE_RETURN_TEXT(BTM_LE_OOB_REQ_EVT);
			CASE_RETURN_TEXT(BTM_LE_NC_REQ_EVT);
			CASE_RETURN_TEXT(BTM_LE_PR_KEYPR_NOT_EVT);
			CASE_RETURN_TEXT(BTM_LE_SC_OOB_REQ_EVT);
			CASE_RETURN_TEXT(BTM_LE_SC_LOC_OOB_EVT);
			CASE_RETURN_TEXT(BTM_LE_COMPLT_EVT);
			CASE_RETURN_TEXT(BTM_LE_LAST_FROM_SMP);
			CASE_RETURN_TEXT(BTM_LE_KEY_EVT);
			CASE_RETURN_TEXT(BTM_LE_CONSENT_REQ_EVT);
			CASE_RETURN_TEXT(BTM_LE_ADDR_ASSOC_EVT);
			}

			return base::StringPrintf("UNKNOWN[%hhu]", evt);
			}

	enum : uint8_t {		enum : uint8_t {
	BTM_LE_KEY_NONE = 0,		BTM_LE_KEY_NONE = 0,