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

Commit 04f10d13 authored by Chris Manton's avatar Chris Manton
Browse files

stack::sdp::tSDP_STATE Class enum-ify 

Bug: 347806116
Test: m .
Flag: EXEMPT, Mechanical Refactor

Change-Id: I8a4d620286a8c0f393fbfb62ed0aa4915e0ac9c3
parent 7b034a62

system/stack/sdp/sdp_main.cc

+12 −10
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ static void sdp_connect_ind(const RawAddress& bd_addr, uint16_t l2cap_cid, 
  if (p_ccb == NULL) return;



  /* Transition to the next appropriate state, waiting for config setup. */

  p_ccb->con_state = SDP_STATE_CFG_SETUP;

  p_ccb->con_state = tSDP_STATE::SDP_STATE_CFG_SETUP;



  /* Save the BD Address and Channel ID. */

  p_ccb->device_address = bd_addr;
@@ -98,8 +98,9 @@ static void sdp_connect_cfm(uint16_t l2cap_cid, uint16_t result) { 


  /* If the connection response contains success status, then */

  /* Transition to the next state and startup the timer.      */

  if ((result == L2CAP_CONN_OK) && (p_ccb->con_state == SDP_STATE_CONN_SETUP)) {

    p_ccb->con_state = SDP_STATE_CFG_SETUP;

  if ((result == L2CAP_CONN_OK) &&

      (p_ccb->con_state == tSDP_STATE::SDP_STATE_CONN_SETUP)) {

    p_ccb->con_state = tSDP_STATE::SDP_STATE_CFG_SETUP;

  } else {

    log::error("invoked with non OK status");

  }
@@ -166,7 +167,7 @@ static void sdp_config_cfm(uint16_t l2cap_cid, uint16_t /* initiator */, 
  }



  /* For now, always accept configuration from the other side */

  p_ccb->con_state = SDP_STATE_CONNECTED;

  p_ccb->con_state = tSDP_STATE::SDP_STATE_CONNECTED;



  if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG) {

    sdp_disc_connected(p_ccb);
@@ -198,8 +199,9 @@ static void sdp_disconnect_ind(uint16_t l2cap_cid, bool ack_needed) { 
  }

  tCONN_CB& ccb = *p_ccb;



  const tSDP_REASON reason =

      (ccb.con_state == SDP_STATE_CONNECTED) ? SDP_SUCCESS : SDP_CONN_FAILED;

  const tSDP_REASON reason = (ccb.con_state == tSDP_STATE::SDP_STATE_CONNECTED)

                                 ? SDP_SUCCESS

                                 : SDP_CONN_FAILED;

  sdpu_callback(ccb, reason);



  if (ack_needed) {
@@ -234,7 +236,7 @@ static void sdp_data_ind(uint16_t l2cap_cid, BT_HDR* p_msg) { 
  /* Find CCB based on CID */

  p_ccb = sdpu_find_ccb_by_cid(l2cap_cid);

  if (p_ccb != NULL) {

    if (p_ccb->con_state == SDP_STATE_CONNECTED) {

    if (p_ccb->con_state == tSDP_STATE::SDP_STATE_CONNECTED) {

      if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)

        sdp_disc_server_rsp(p_ccb, p_msg);

      else
@@ -285,10 +287,10 @@ tCONN_CB* sdp_conn_originate(const RawAddress& bd_addr) { 
  /* Transition to the next appropriate state, waiting for connection confirm */

  if (!bluetooth::common::init_flags::sdp_serialization_is_enabled() ||

      cid == 0) {

    p_ccb->con_state = SDP_STATE_CONN_SETUP;

    p_ccb->con_state = tSDP_STATE::SDP_STATE_CONN_SETUP;

    cid = L2CA_ConnectReqWithSecurity(BT_PSM_SDP, bd_addr, BTM_SEC_NONE);

  } else {

    p_ccb->con_state = SDP_STATE_CONN_PEND;

    p_ccb->con_state = tSDP_STATE::SDP_STATE_CONN_PEND;

    log::warn("SDP already active for peer {}. cid={:#0x}", bd_addr, cid);

  }
@@ -332,7 +334,7 @@ void sdp_disconnect(tCONN_CB* p_ccb, tSDP_REASON reason) { 


  /* If at setup state, we may not get callback ind from L2CAP */

  /* Call user callback immediately */

  if (ccb.con_state == SDP_STATE_CONN_SETUP) {

  if (ccb.con_state == tSDP_STATE::SDP_STATE_CONN_SETUP) {

    sdpu_callback(ccb, reason);

    sdpu_clear_pend_ccb(ccb);

    sdpu_release_ccb(ccb);

system/stack/sdp/sdp_utils.cc

+14 −13
Original line number Diff line number Diff line
@@ -337,8 +337,8 @@ tCONN_CB* sdpu_find_ccb_by_cid(uint16_t cid) { 


  /* Look through each connection control block */

  for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++) {

    if ((p_ccb->con_state != SDP_STATE_IDLE) &&

        (p_ccb->con_state != SDP_STATE_CONN_PEND) &&

    if ((p_ccb->con_state != tSDP_STATE::SDP_STATE_IDLE) &&

        (p_ccb->con_state != tSDP_STATE::SDP_STATE_CONN_PEND) &&

        (p_ccb->connection_id == cid)) {

      return (p_ccb);

    }
@@ -365,7 +365,8 @@ tCONN_CB* sdpu_find_ccb_by_db(const tSDP_DISCOVERY_DB* p_db) { 
  if (p_db) {

    /* Look through each connection control block */

    for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++) {

      if ((p_ccb->con_state != SDP_STATE_IDLE) && (p_ccb->p_db == p_db))

      if ((p_ccb->con_state != tSDP_STATE::SDP_STATE_IDLE) &&

          (p_ccb->p_db == p_db))

        return (p_ccb);

    }

  }
@@ -388,7 +389,7 @@ tCONN_CB* sdpu_allocate_ccb(void) { 


  /* Look through each connection control block for a free one */

  for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++) {

    if (p_ccb->con_state == SDP_STATE_IDLE) {

    if (p_ccb->con_state == tSDP_STATE::SDP_STATE_IDLE) {

      alarm_t* alarm = p_ccb->sdp_conn_timer;

      *p_ccb = {};

      p_ccb->sdp_conn_timer = alarm;
@@ -431,7 +432,7 @@ void sdpu_release_ccb(tCONN_CB& ccb) { 
  alarm_cancel(ccb.sdp_conn_timer);



  /* Drop any response pointer we may be holding */

  ccb.con_state = SDP_STATE_IDLE;

  ccb.con_state = tSDP_STATE::SDP_STATE_IDLE;

  ccb.is_attr_search = false;



  /* Free the response buffer */
@@ -457,9 +458,9 @@ uint16_t sdpu_get_active_ccb_cid(const RawAddress& bd_addr) { 


  // Look through each connection control block for active sdp on given remote

  for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++) {

    if ((p_ccb->con_state == SDP_STATE_CONN_SETUP) ||

        (p_ccb->con_state == SDP_STATE_CFG_SETUP) ||

        (p_ccb->con_state == SDP_STATE_CONNECTED)) {

    if ((p_ccb->con_state == tSDP_STATE::SDP_STATE_CONN_SETUP) ||

        (p_ccb->con_state == tSDP_STATE::SDP_STATE_CFG_SETUP) ||

        (p_ccb->con_state == tSDP_STATE::SDP_STATE_CONNECTED)) {

      if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG &&

          p_ccb->device_address == bd_addr) {

        return p_ccb->connection_id;
@@ -489,10 +490,10 @@ bool sdpu_process_pend_ccb_same_cid(tCONN_CB& ccb) { 


  // Look through each connection control block for active sdp on given remote

  for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++) {

    if ((p_ccb->con_state == SDP_STATE_CONN_PEND) &&

    if ((p_ccb->con_state == tSDP_STATE::SDP_STATE_CONN_PEND) &&

        (p_ccb->connection_id == ccb.connection_id) &&

        (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)) {

      p_ccb->con_state = SDP_STATE_CONNECTED;

      p_ccb->con_state = tSDP_STATE::SDP_STATE_CONNECTED;

      sdp_disc_connected(p_ccb);

      return true;

    }
@@ -521,12 +522,12 @@ bool sdpu_process_pend_ccb_new_cid(tCONN_CB& ccb) { 


  // Look through each ccb to replace the obsolete cid with a new one.

  for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++) {

    if ((p_ccb->con_state == SDP_STATE_CONN_PEND) &&

    if ((p_ccb->con_state == tSDP_STATE::SDP_STATE_CONN_PEND) &&

        (p_ccb->connection_id == ccb.connection_id) &&

        (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)) {

      if (!new_conn) {

        // Only change state of the first ccb

        p_ccb->con_state = SDP_STATE_CONN_SETUP;

        p_ccb->con_state = tSDP_STATE::SDP_STATE_CONN_SETUP;

        new_cid = L2CA_ConnectReqWithSecurity(BT_PSM_SDP, p_ccb->device_address,

                                              BTM_SEC_NONE);

        new_conn = true;
@@ -561,7 +562,7 @@ void sdpu_clear_pend_ccb(tCONN_CB& ccb) { 


  // Look through each connection control block for active sdp on given remote

  for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++) {

    if ((p_ccb->con_state == SDP_STATE_CONN_PEND) &&

    if ((p_ccb->con_state == tSDP_STATE::SDP_STATE_CONN_PEND) &&

        (p_ccb->connection_id == ccb.connection_id) &&

        (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)) {

      sdpu_callback(*p_ccb, SDP_CONN_FAILED);

system/stack/sdp/sdpint.h

+7 −9
Original line number Diff line number Diff line
@@ -128,25 +128,23 @@ typedef struct { 
                           attributes in the responses */

} tSDP_CONT_INFO;



enum : uint8_t {

enum class tSDP_STATE : uint8_t {

  SDP_STATE_IDLE = 0,

  SDP_STATE_CONN_SETUP = 1,

  SDP_STATE_CFG_SETUP = 2,

  SDP_STATE_CONNECTED = 3,

  SDP_STATE_CONN_PEND = 4,

};

typedef uint8_t tSDP_STATE;



inline std::string sdp_state_text(const tSDP_STATE& state) {

  switch (state) {

    CASE_RETURN_TEXT(SDP_STATE_IDLE);

    CASE_RETURN_TEXT(SDP_STATE_CONN_SETUP);

    CASE_RETURN_TEXT(SDP_STATE_CFG_SETUP);

    CASE_RETURN_TEXT(SDP_STATE_CONNECTED);

    CASE_RETURN_TEXT(SDP_STATE_CONN_PEND);

    default:

      return std::string("UNKNOWN[") + std::to_string(state) + std::string("]");

    CASE_RETURN_STRING(tSDP_STATE::SDP_STATE_IDLE);

    CASE_RETURN_STRING(tSDP_STATE::SDP_STATE_CONN_SETUP);

    CASE_RETURN_STRING(tSDP_STATE::SDP_STATE_CFG_SETUP);

    CASE_RETURN_STRING(tSDP_STATE::SDP_STATE_CONNECTED);

    CASE_RETURN_STRING(tSDP_STATE::SDP_STATE_CONN_PEND);

  }

  RETURN_UNKNOWN_TYPE_STRING(tSDP_STATE, state);

}



enum : uint8_t {

system/stack/test/sdp/stack_sdp_parse_test.cc

+1 −1
Original line number Diff line number Diff line
@@ -130,7 +130,7 @@ class StackSdpAsClientParseTest : public StackSdpParserInitTest { 
    p_ccb_ = sdpu_find_ccb_by_db(p_db_);

    ASSERT_NE(nullptr, p_ccb_);

    p_ccb_->disc_state = SDP_DISC_WAIT_SEARCH_ATTR;

    p_ccb_->con_state = SDP_STATE_CONNECTED;

    p_ccb_->con_state = tSDP_STATE::SDP_STATE_CONNECTED;

    p_ccb_->con_flags = SDP_FLAGS_IS_ORIG;

  }

system/stack/test/sdp/stack_sdp_test.cc

+33 −25
Original line number Diff line number Diff line
@@ -20,6 +20,7 @@ 


#include <cstddef>



#include "include/macros.h"

#include "osi/include/allocator.h"

#include "stack/include/bt_uuid16.h"

#include "stack/include/sdpdefs.h"
@@ -99,17 +100,17 @@ TEST_F(StackSdpInitTest, sdp_service_search_request) { 
  int cid = L2CA_ConnectReqWithSecurity_cid;

  tCONN_CB* p_ccb = sdpu_find_ccb_by_cid(cid);

  ASSERT_NE(p_ccb, nullptr);

  ASSERT_EQ(p_ccb->con_state, SDP_STATE_CONN_SETUP);

  ASSERT_EQ(p_ccb->con_state, tSDP_STATE::SDP_STATE_CONN_SETUP);



  tL2CAP_CFG_INFO cfg;

  sdp_cb.reg_info.pL2CA_ConfigCfm_Cb(p_ccb->connection_id, 0, &cfg);



  ASSERT_EQ(p_ccb->con_state, SDP_STATE_CONNECTED);

  ASSERT_EQ(p_ccb->con_state, tSDP_STATE::SDP_STATE_CONNECTED);



  sdp_disconnect(p_ccb, SDP_SUCCESS);

  sdp_cb.reg_info.pL2CA_DisconnectCfm_Cb(p_ccb->connection_id, 0);



  ASSERT_EQ(p_ccb->con_state, SDP_STATE_IDLE);

  ASSERT_EQ(p_ccb->con_state, tSDP_STATE::SDP_STATE_IDLE);

}



tCONN_CB* find_ccb(uint16_t cid, tSDP_STATE state) {
@@ -128,33 +129,33 @@ tCONN_CB* find_ccb(uint16_t cid, tSDP_STATE state) { 
TEST_F(StackSdpInitTest, sdp_service_search_request_queuing) {

  ASSERT_TRUE(SDP_ServiceSearchRequest(addr, sdp_db, nullptr));

  const int cid = L2CA_ConnectReqWithSecurity_cid;

  tCONN_CB* p_ccb1 = find_ccb(cid, SDP_STATE_CONN_SETUP);

  tCONN_CB* p_ccb1 = find_ccb(cid, tSDP_STATE::SDP_STATE_CONN_SETUP);

  ASSERT_NE(p_ccb1, nullptr);

  ASSERT_EQ(p_ccb1->con_state, SDP_STATE_CONN_SETUP);

  ASSERT_EQ(p_ccb1->con_state, tSDP_STATE::SDP_STATE_CONN_SETUP);



  ASSERT_TRUE(SDP_ServiceSearchRequest(addr, sdp_db, nullptr));

  tCONN_CB* p_ccb2 = find_ccb(cid, SDP_STATE_CONN_PEND);

  tCONN_CB* p_ccb2 = find_ccb(cid, tSDP_STATE::SDP_STATE_CONN_PEND);

  ASSERT_NE(p_ccb2, nullptr);

  ASSERT_NE(p_ccb2, p_ccb1);

  ASSERT_EQ(p_ccb2->con_state, SDP_STATE_CONN_PEND);

  ASSERT_EQ(p_ccb2->con_state, tSDP_STATE::SDP_STATE_CONN_PEND);



  tL2CAP_CFG_INFO cfg;

  sdp_cb.reg_info.pL2CA_ConfigCfm_Cb(p_ccb1->connection_id, 0, &cfg);



  ASSERT_EQ(p_ccb1->con_state, SDP_STATE_CONNECTED);

  ASSERT_EQ(p_ccb2->con_state, SDP_STATE_CONN_PEND);

  ASSERT_EQ(p_ccb1->con_state, tSDP_STATE::SDP_STATE_CONNECTED);

  ASSERT_EQ(p_ccb2->con_state, tSDP_STATE::SDP_STATE_CONN_PEND);



  p_ccb1->disconnect_reason = SDP_SUCCESS;

  sdp_disconnect(p_ccb1, SDP_SUCCESS);



  ASSERT_EQ(p_ccb1->con_state, SDP_STATE_IDLE);

  ASSERT_EQ(p_ccb2->con_state, SDP_STATE_CONNECTED);

  ASSERT_EQ(p_ccb1->con_state, tSDP_STATE::SDP_STATE_IDLE);

  ASSERT_EQ(p_ccb2->con_state, tSDP_STATE::SDP_STATE_CONNECTED);



  sdp_disconnect(p_ccb2, SDP_SUCCESS);

  sdp_cb.reg_info.pL2CA_DisconnectCfm_Cb(p_ccb2->connection_id, 0);



  ASSERT_EQ(p_ccb1->con_state, SDP_STATE_IDLE);

  ASSERT_EQ(p_ccb2->con_state, SDP_STATE_IDLE);

  ASSERT_EQ(p_ccb1->con_state, tSDP_STATE::SDP_STATE_IDLE);

  ASSERT_EQ(p_ccb2->con_state, tSDP_STATE::SDP_STATE_IDLE);

}



void sdp_callback(const RawAddress& /* bd_addr */, tSDP_RESULT result) {
@@ -167,24 +168,24 @@ TEST_F(StackSdpInitTest, sdp_service_search_request_queuing_race_condition) { 
  // start first request

  ASSERT_TRUE(SDP_ServiceSearchRequest(addr, sdp_db, sdp_callback));

  const int cid1 = L2CA_ConnectReqWithSecurity_cid;

  tCONN_CB* p_ccb1 = find_ccb(cid1, SDP_STATE_CONN_SETUP);

  tCONN_CB* p_ccb1 = find_ccb(cid1, tSDP_STATE::SDP_STATE_CONN_SETUP);

  ASSERT_NE(p_ccb1, nullptr);

  ASSERT_EQ(p_ccb1->con_state, SDP_STATE_CONN_SETUP);

  ASSERT_EQ(p_ccb1->con_state, tSDP_STATE::SDP_STATE_CONN_SETUP);



  tL2CAP_CFG_INFO cfg;

  sdp_cb.reg_info.pL2CA_ConfigCfm_Cb(p_ccb1->connection_id, 0, &cfg);



  ASSERT_EQ(p_ccb1->con_state, SDP_STATE_CONNECTED);

  ASSERT_EQ(p_ccb1->con_state, tSDP_STATE::SDP_STATE_CONNECTED);



  sdp_disconnect(p_ccb1, SDP_SUCCESS);

  sdp_cb.reg_info.pL2CA_DisconnectCfm_Cb(p_ccb1->connection_id, 0);



  const int cid2 = L2CA_ConnectReqWithSecurity_cid;

  ASSERT_NE(cid1, cid2);  // The callback a queued a new request

  tCONN_CB* p_ccb2 = find_ccb(cid2, SDP_STATE_CONN_SETUP);

  tCONN_CB* p_ccb2 = find_ccb(cid2, tSDP_STATE::SDP_STATE_CONN_SETUP);

  ASSERT_NE(p_ccb2, nullptr);

  // If race condition, this will be stuck in PEND

  ASSERT_EQ(p_ccb2->con_state, SDP_STATE_CONN_SETUP);

  ASSERT_EQ(p_ccb2->con_state, tSDP_STATE::SDP_STATE_CONN_SETUP);



  sdp_disconnect(p_ccb2, SDP_SUCCESS);

}
@@ -210,17 +211,24 @@ TEST_F(StackSdpInitTest, sdp_disc_wait_text) { 


TEST_F(StackSdpInitTest, sdp_state_text) {

  std::vector<std::pair<tSDP_STATE, std::string>> states = {

      std::make_pair(SDP_STATE_IDLE, "SDP_STATE_IDLE"),

      std::make_pair(SDP_STATE_CONN_SETUP, "SDP_STATE_CONN_SETUP"),

      std::make_pair(SDP_STATE_CFG_SETUP, "SDP_STATE_CFG_SETUP"),

      std::make_pair(SDP_STATE_CONNECTED, "SDP_STATE_CONNECTED"),

      std::make_pair(SDP_STATE_CONN_PEND, "SDP_STATE_CONN_PEND"),

      std::make_pair(tSDP_STATE::SDP_STATE_IDLE,

                     "tSDP_STATE::SDP_STATE_IDLE(0x0)"),

      std::make_pair(tSDP_STATE::SDP_STATE_CONN_SETUP,

                     "tSDP_STATE::SDP_STATE_CONN_SETUP(0x1)"),

      std::make_pair(tSDP_STATE::SDP_STATE_CFG_SETUP,

                     "tSDP_STATE::SDP_STATE_CFG_SETUP(0x2)"),

      std::make_pair(tSDP_STATE::SDP_STATE_CONNECTED,

                     "tSDP_STATE::SDP_STATE_CONNECTED(0x3)"),

      std::make_pair(tSDP_STATE::SDP_STATE_CONN_PEND,

                     "tSDP_STATE::SDP_STATE_CONN_PEND(0x4)"),

  };

  for (const auto& state : states) {

    ASSERT_STREQ(state.second.c_str(), sdp_state_text(state.first).c_str());

  }

  auto unknown = base::StringPrintf("UNKNOWN[%hhu]",

  auto unknown = []() {

    RETURN_UNKNOWN_TYPE_STRING(tSDP_STATE,

                               std::numeric_limits<std::uint8_t>::max());

  }();

  ASSERT_STREQ(unknown.c_str(),

               sdp_state_text(static_cast<tSDP_STATE>(

                                  std::numeric_limits<std::uint8_t>::max()))