Merge changes Id0a22412,I4a18d89e,I8b70fb37,I3d030824 am: fd98c84de3 am: 2b0933f18f (720f6679) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/gatt/att_protocol.cc

+33 −10

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

		#include "gatt_int.h"
		#include "l2c_api.h"
		#include "osi/include/log.h"

		#define GATT_HDR_FIND_TYPE_VALUE_LEN 21
		#define GATT_OP_CODE_SIZE 1
		@@ -326,10 +327,13 @@ tGATT_STATUS attp_send_msg_to_l2cap(tGATT_TCB& tcb, uint16_t lcid,
		BT_HDR* p_toL2CAP) {
		uint16_t l2cap_ret;

		if (lcid == L2CAP_ATT_CID)
		if (lcid == L2CAP_ATT_CID) {
		LOG_DEBUG("Sending ATT message on att fixed channel");
		l2cap_ret = L2CA_SendFixedChnlData(lcid, tcb.peer_bda, p_toL2CAP);
		else
		} else {
		LOG_DEBUG("Sending ATT message on lcid:%hu", lcid);
		l2cap_ret = (uint16_t)L2CA_DataWrite(lcid, p_toL2CAP);
		}

		if (l2cap_ret == L2CAP_DW_FAILED) {
		LOG(ERROR) << __func__ << ": failed to write data to L2CAP";
		@@ -421,20 +425,21 @@ tGATT_STATUS attp_cl_send_cmd(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
		if (gatt_tcb_is_cid_busy(tcb, p_clcb->cid) &&
		cmd_code != GATT_HANDLE_VALUE_CONF) {
		gatt_cmd_enq(tcb, p_clcb, true, cmd_code, p_cmd);
		LOG_DEBUG("Enqueued ATT command");
		return GATT_CMD_STARTED;
		}

		/* no pending request or value confirmation */
		tGATT_STATUS att_ret = attp_send_msg_to_l2cap(tcb, p_clcb->cid, p_cmd);
		if (att_ret != GATT_CONGESTED && att_ret != GATT_SUCCESS) {
		LOG_WARN("Unable to send ATT command to l2cap layer");
		return GATT_INTERNAL_ERROR;
		}

		/* do not enq cmd if handle value confirmation or set request */
		if (cmd_code == GATT_HANDLE_VALUE_CONF \|\| cmd_code == GATT_CMD_WRITE) {
		return att_ret;
		}

		LOG_DEBUG("Starting ATT response timer");
		gatt_start_rsp_timer(p_clcb);
		gatt_cmd_enq(tcb, p_clcb, false, cmd_code, NULL);
		return att_ret;
		@@ -491,7 +496,7 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
		uint16_t offset = 0, handle;

		if (!p_clcb) {
		LOG(ERROR) << "Missing p_clcb" << +op_code;
		LOG_ERROR("Missing p_clcb");
		return GATT_ILLEGAL_PARAMETER;
		}

		@@ -499,7 +504,12 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,

		switch (op_code) {
		case GATT_REQ_MTU:
		if (p_msg->mtu > GATT_MAX_MTU_SIZE) return GATT_ILLEGAL_PARAMETER;
		if (p_msg->mtu > GATT_MAX_MTU_SIZE) {
		LOG_WARN(
		"GATT message MTU is larger than max GATT MTU size op_code:%hhu",
		op_code);
		return GATT_ILLEGAL_PARAMETER;
		}

		tcb.payload_size = p_msg->mtu;
		p_cmd = attp_build_mtu_cmd(GATT_REQ_MTU, p_msg->mtu);
		@@ -510,8 +520,10 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
		case GATT_REQ_READ_BY_GRP_TYPE:
		if (!GATT_HANDLE_IS_VALID(p_msg->browse.s_handle) \|\|
		!GATT_HANDLE_IS_VALID(p_msg->browse.e_handle) \|\|
		p_msg->browse.s_handle > p_msg->browse.e_handle)
		p_msg->browse.s_handle > p_msg->browse.e_handle) {
		LOG_WARN("GATT message has invalid handle op_code:%hhu", op_code);
		return GATT_ILLEGAL_PARAMETER;
		}

		p_cmd = attp_build_browse_cmd(op_code, p_msg->browse.s_handle,
		p_msg->browse.e_handle, p_msg->browse.uuid);
		@@ -524,7 +536,10 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
		handle =
		(op_code == GATT_REQ_READ) ? p_msg->handle : p_msg->read_blob.handle;
		/* handle checking */
		if (!GATT_HANDLE_IS_VALID(handle)) return GATT_ILLEGAL_PARAMETER;
		if (!GATT_HANDLE_IS_VALID(handle)) {
		LOG_WARN("GATT message has invalid handle op_code:%hhu", op_code);
		return GATT_ILLEGAL_PARAMETER;
		}

		p_cmd = attp_build_handle_cmd(op_code, handle, offset);
		break;
		@@ -535,8 +550,10 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
		case GATT_REQ_WRITE:
		case GATT_CMD_WRITE:
		case GATT_SIGN_CMD_WRITE:
		if (!GATT_HANDLE_IS_VALID(p_msg->attr_value.handle))
		if (!GATT_HANDLE_IS_VALID(p_msg->attr_value.handle)) {
		LOG_WARN("GATT message has invalid handle op_code:%hhu", op_code);
		return GATT_ILLEGAL_PARAMETER;
		}

		p_cmd = attp_build_value_cmd(
		payload_size, op_code, p_msg->attr_value.handle, offset,
		@@ -562,7 +579,13 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb,
		break;
		}

		if (p_cmd == NULL) return GATT_NO_RESOURCES;
		if (p_cmd == NULL) {
		LOG_WARN(
		"Unable to build proper GATT message to send to peer device "
		"op_code:%hhu",
		op_code);
		return GATT_NO_RESOURCES;
		}

		return attp_cl_send_cmd(tcb, p_clcb, op_code, p_cmd);
		}

system/stack/gatt/gatt_cl.cc

+3 −1

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@
		#include "gatt_int.h"
		#include "l2c_api.h"
		#include "log/log.h"
		#include "osi/include/log.h"
		#include "osi/include/osi.h"

		#define GATT_WRITE_LONG_HDR_SIZE 5 /* 1 opcode + 2 handle + 2 offset */
		@@ -84,7 +85,7 @@ void gatt_act_discovery(tGATT_CLCB* p_clcb) {
		uint8_t op_code = disc_type_to_att_opcode[p_clcb->op_subtype];

		if (p_clcb->s_handle > p_clcb->e_handle \|\| p_clcb->s_handle == 0) {
		/* end of handle range */
		LOG_DEBUG("Completed GATT discovery of all handle ranges");
		gatt_end_operation(p_clcb, GATT_SUCCESS, NULL);
		return;
		}
		@@ -125,6 +126,7 @@ void gatt_act_discovery(tGATT_CLCB* p_clcb) {

		tGATT_STATUS st = attp_send_cl_msg(*p_clcb->p_tcb, p_clcb, op_code, &cl_req);
		if (st != GATT_SUCCESS && st != GATT_CMD_STARTED) {
		LOG_WARN("Unable to send ATT message");
		gatt_end_operation(p_clcb, GATT_ERROR, NULL);
		}
		}

system/stack/include/btm_api_types.h

+5 −4

Original line number	Diff line number	Diff line
		@@ -462,10 +462,11 @@ typedef void(tBTM_ESCO_CBACK)(tBTM_ESCO_EVT event, tBTM_ESCO_EVT_DATA* p_data);
		* Security Manager Constants
		*******************************/

		/* Security Mode (BTM_SetSecurityMode) */
		#define BTM_SEC_MODE_SERVICE 2
		#define BTM_SEC_MODE_SP 4
		#define BTM_SEC_MODE_SC 6
		typedef enum : uint8_t {
		BTM_SEC_MODE_SERVICE = 2,
		BTM_SEC_MODE_SP = 4,
		BTM_SEC_MODE_SC = 6,
		} tSECURITY_MODE;

		/* Security Service Levels [bit mask] (BTM_SetSecurityLevel)
		* Encryption should not be used without authentication

system/stack/l2cap/l2c_api.cc

+16 −24

Original line number	Diff line number	Diff line
		@@ -1287,36 +1287,28 @@ uint16_t L2CA_SendFixedChnlData(uint16_t fixed_cid, const RawAddress& rem_bda,
		tL2C_LCB* p_lcb;
		tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;

		VLOG(2) << __func__ << " BDA: " << rem_bda
		<< StringPrintf(" CID: 0x%04x", fixed_cid);

		if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID)
		transport = BT_TRANSPORT_LE;

		// Check CID is valid and registered
		if ((fixed_cid < L2CAP_FIRST_FIXED_CHNL) \|\|
		(fixed_cid > L2CAP_LAST_FIXED_CHNL) \|\|
		(l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb ==
		NULL)) {
		L2CAP_TRACE_ERROR("L2CA_SendFixedChnlData() Invalid CID: 0x%04x",
		fixed_cid);
		LOG_WARN("No service registered or invalid CID: 0x%04x", fixed_cid);
		osi_free(p_buf);
		return (L2CAP_DW_FAILED);
		}

		// Fail if BT is not yet up
		if (!BTM_IsDeviceUp()) {
		L2CAP_TRACE_WARNING("L2CA_SendFixedChnlData(0x%04x) - BTU not ready",
		fixed_cid);
		LOG_WARN("Controller is not ready CID: 0x%04x", fixed_cid);
		osi_free(p_buf);
		return (L2CAP_DW_FAILED);
		}

		// We need to have a link up
		p_lcb = l2cu_find_lcb_by_bd_addr(rem_bda, transport);
		if (p_lcb == NULL \|\| p_lcb->link_state == LST_DISCONNECTING) {
		/* if link is disconnecting, also report data sending failure */
		L2CAP_TRACE_WARNING("L2CA_SendFixedChnlData(0x%04x) - no LCB", fixed_cid);
		LOG_WARN("Link is disconnecting or does not exist CID: 0x%04x", fixed_cid);
		osi_free(p_buf);
		return (L2CAP_DW_FAILED);
		}
		@@ -1330,9 +1322,7 @@ uint16_t L2CA_SendFixedChnlData(uint16_t fixed_cid, const RawAddress& rem_bda,
		peer_channel_mask = p_lcb->peer_chnl_mask[0];

		if ((peer_channel_mask & (1 << fixed_cid)) == 0) {
		L2CAP_TRACE_WARNING(
		"L2CA_SendFixedChnlData() - peer does not support fixed chnl: 0x%04x",
		fixed_cid);
		LOG_WARN("Peer does not support fixed channel CID: 0x%04x", fixed_cid);
		osi_free(p_buf);
		return (L2CAP_DW_FAILED);
		}
		@@ -1342,19 +1332,18 @@ uint16_t L2CA_SendFixedChnlData(uint16_t fixed_cid, const RawAddress& rem_bda,

		if (!p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]) {
		if (!l2cu_initialize_fixed_ccb(p_lcb, fixed_cid)) {
		L2CAP_TRACE_WARNING("L2CA_SendFixedChnlData() - no CCB for chnl: 0x%4x",
		fixed_cid);
		LOG_WARN("No channel control block found for CID: 0x%4x", fixed_cid);
		osi_free(p_buf);
		return (L2CAP_DW_FAILED);
		}
		}

		// If already congested, do not accept any more packets
		if (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->cong_sent) {
		L2CAP_TRACE_ERROR(
		"L2CAP - CID: 0x%04x cannot send, already congested \
		xmit_hold_q.count: %u buff_quota: %u",
		fixed_cid, fixed_queue_length(
		LOG_WARN(
		"Unable to send data due to congestion CID: 0x%04x xmit_hold_q.count: "
		"%zu buff_quota: %u",
		fixed_cid,
		fixed_queue_length(
		p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]
		->xmit_hold_q),
		p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->buff_quota);
		@@ -1362,6 +1351,7 @@ uint16_t L2CA_SendFixedChnlData(uint16_t fixed_cid, const RawAddress& rem_bda,
		return (L2CAP_DW_FAILED);
		}

		LOG_DEBUG("Enqueued data for CID: 0x%04x len:%hu", fixed_cid, p_buf->len);
		l2c_enqueue_peer_data(p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL],
		p_buf);

		@@ -1374,8 +1364,10 @@ uint16_t L2CA_SendFixedChnlData(uint16_t fixed_cid, const RawAddress& rem_bda,
		l2cu_no_dynamic_ccbs(p_lcb);
		}

		if (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->cong_sent)
		if (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->cong_sent) {
		LOG_DEBUG("Link congested for CID: 0x%04x", fixed_cid);
		return (L2CAP_DW_CONGESTED);
		}

		return (L2CAP_DW_SUCCESS);
		}