Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fd98c84d authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes Id0a22412,I4a18d89e,I8b70fb37,I3d030824 

* changes:
  enum-ify stack/include/btm_api_types::BTM_SEC_MODE_
  Re-log stack/l2cap/l2c_api::L2CA_SendFixedChnlData
  Re-log stack/gatt/gatt_cl::gatt_act_discovery
  Re-log stack/gatt/att_protocol::attp_send_msg_to_l2cap
parents fccaa155 cc9094dc

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);

}