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

Commit 1a76f050 authored by Chris Manton's avatar Chris Manton Committed by Automerger Merge Worker
Browse files

stack::sdp::tSDP_STATE Streamline enum names am: d9017723 am: 991987ea 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3136157



Change-Id: Ia3fadce270fef45bfc10a8232be9c6329f44fdb3
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents e67416a0 991987ea

system/stack/sdp/sdp_main.cc

+10 −11
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 = tSDP_STATE::SDP_STATE_CFG_SETUP;

  p_ccb->con_state = tSDP_STATE::CFG_SETUP;



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

  p_ccb->device_address = bd_addr;
@@ -99,8 +99,8 @@ 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 == tSDP_STATE::SDP_STATE_CONN_SETUP)) {

    p_ccb->con_state = tSDP_STATE::SDP_STATE_CFG_SETUP;

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

    p_ccb->con_state = tSDP_STATE::CFG_SETUP;

  } else {

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

  }
@@ -167,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 = tSDP_STATE::SDP_STATE_CONNECTED;

  p_ccb->con_state = tSDP_STATE::CONNECTED;



  if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG) {

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

  tCONN_CB& ccb = *p_ccb;



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

                                 ? SDP_SUCCESS

                                 : SDP_CONN_FAILED;

  const tSDP_REASON reason =

      (ccb.con_state == tSDP_STATE::CONNECTED) ? SDP_SUCCESS : SDP_CONN_FAILED;

  sdpu_callback(ccb, reason);



  if (ack_needed) {
@@ -236,7 +235,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 == tSDP_STATE::SDP_STATE_CONNECTED) {

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

      if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)

        sdp_disc_server_rsp(p_ccb, p_msg);

      else
@@ -287,10 +286,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 = tSDP_STATE::SDP_STATE_CONN_SETUP;

    p_ccb->con_state = tSDP_STATE::CONN_SETUP;

    cid = L2CA_ConnectReqWithSecurity(BT_PSM_SDP, bd_addr, BTM_SEC_NONE);

  } else {

    p_ccb->con_state = tSDP_STATE::SDP_STATE_CONN_PEND;

    p_ccb->con_state = tSDP_STATE::CONN_PEND;

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

  }
@@ -334,7 +333,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 == tSDP_STATE::SDP_STATE_CONN_SETUP) {

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

    sdpu_callback(ccb, reason);

    sdpu_clear_pend_ccb(ccb);

    sdpu_release_ccb(ccb);

system/stack/sdp/sdp_utils.cc

+13 −14
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 != tSDP_STATE::SDP_STATE_IDLE) &&

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

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

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

        (p_ccb->connection_id == cid)) {

      return (p_ccb);

    }
@@ -365,8 +365,7 @@ 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 != tSDP_STATE::SDP_STATE_IDLE) &&

          (p_ccb->p_db == p_db))

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

        return (p_ccb);

    }

  }
@@ -389,7 +388,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 == tSDP_STATE::SDP_STATE_IDLE) {

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

      alarm_t* alarm = p_ccb->sdp_conn_timer;

      *p_ccb = {};

      p_ccb->sdp_conn_timer = alarm;
@@ -432,7 +431,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 = tSDP_STATE::SDP_STATE_IDLE;

  ccb.con_state = tSDP_STATE::IDLE;

  ccb.is_attr_search = false;



  /* Free the response buffer */
@@ -458,9 +457,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 == 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_state == tSDP_STATE::CONN_SETUP) ||

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

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

      if (p_ccb->con_flags & SDP_FLAGS_IS_ORIG &&

          p_ccb->device_address == bd_addr) {

        return p_ccb->connection_id;
@@ -490,10 +489,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 == tSDP_STATE::SDP_STATE_CONN_PEND) &&

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

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

        (p_ccb->con_flags & SDP_FLAGS_IS_ORIG)) {

      p_ccb->con_state = tSDP_STATE::SDP_STATE_CONNECTED;

      p_ccb->con_state = tSDP_STATE::CONNECTED;

      sdp_disc_connected(p_ccb);

      return true;

    }
@@ -522,12 +521,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 == tSDP_STATE::SDP_STATE_CONN_PEND) &&

    if ((p_ccb->con_state == tSDP_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 = tSDP_STATE::SDP_STATE_CONN_SETUP;

        p_ccb->con_state = tSDP_STATE::CONN_SETUP;

        new_cid = L2CA_ConnectReqWithSecurity(BT_PSM_SDP, p_ccb->device_address,

                                              BTM_SEC_NONE);

        new_conn = true;
@@ -562,7 +561,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 == tSDP_STATE::SDP_STATE_CONN_PEND) &&

    if ((p_ccb->con_state == tSDP_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

+10 −10
Original line number Diff line number Diff line
@@ -129,20 +129,20 @@ typedef struct { 
} tSDP_CONT_INFO;



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,

  IDLE = 0,

  CONN_SETUP = 1,

  CFG_SETUP = 2,

  CONNECTED = 3,

  CONN_PEND = 4,

};



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

  switch (state) {

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

    CASE_RETURN_STRING(tSDP_STATE::IDLE);

    CASE_RETURN_STRING(tSDP_STATE::CONN_SETUP);

    CASE_RETURN_STRING(tSDP_STATE::CFG_SETUP);

    CASE_RETURN_STRING(tSDP_STATE::CONNECTED);

    CASE_RETURN_STRING(tSDP_STATE::CONN_PEND);

  }

  RETURN_UNKNOWN_TYPE_STRING(tSDP_STATE, state);

}

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 = tSDP_STATE::SDP_STATE_CONNECTED;

    p_ccb_->con_state = tSDP_STATE::CONNECTED;

    p_ccb_->con_flags = SDP_FLAGS_IS_ORIG;

  }

system/stack/test/sdp/stack_sdp_test.cc

+23 −28
Original line number Diff line number Diff line
@@ -100,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, tSDP_STATE::SDP_STATE_CONN_SETUP);

  ASSERT_EQ(p_ccb->con_state, tSDP_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, tSDP_STATE::SDP_STATE_CONNECTED);

  ASSERT_EQ(p_ccb->con_state, tSDP_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, tSDP_STATE::SDP_STATE_IDLE);

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

}



tCONN_CB* find_ccb(uint16_t cid, tSDP_STATE state) {
@@ -129,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, tSDP_STATE::SDP_STATE_CONN_SETUP);

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

  ASSERT_NE(p_ccb1, nullptr);

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

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



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

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

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

  ASSERT_NE(p_ccb2, nullptr);

  ASSERT_NE(p_ccb2, p_ccb1);

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

  ASSERT_EQ(p_ccb2->con_state, tSDP_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, tSDP_STATE::SDP_STATE_CONNECTED);

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

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

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



  p_ccb1->disconnect_reason = SDP_SUCCESS;

  sdp_disconnect(p_ccb1, SDP_SUCCESS);



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

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

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

  ASSERT_EQ(p_ccb2->con_state, tSDP_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, tSDP_STATE::SDP_STATE_IDLE);

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

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

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

}



void sdp_callback(const RawAddress& /* bd_addr */, tSDP_RESULT result) {
@@ -168,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, tSDP_STATE::SDP_STATE_CONN_SETUP);

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

  ASSERT_NE(p_ccb1, nullptr);

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

  ASSERT_EQ(p_ccb1->con_state, tSDP_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, tSDP_STATE::SDP_STATE_CONNECTED);

  ASSERT_EQ(p_ccb1->con_state, tSDP_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, tSDP_STATE::SDP_STATE_CONN_SETUP);

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

  ASSERT_NE(p_ccb2, nullptr);

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

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

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



  sdp_disconnect(p_ccb2, SDP_SUCCESS);

}
@@ -211,16 +211,11 @@ 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(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)"),

      std::make_pair(tSDP_STATE::IDLE, "tSDP_STATE::IDLE(0x0)"),

      std::make_pair(tSDP_STATE::CONN_SETUP, "tSDP_STATE::CONN_SETUP(0x1)"),

      std::make_pair(tSDP_STATE::CFG_SETUP, "tSDP_STATE::CFG_SETUP(0x2)"),

      std::make_pair(tSDP_STATE::CONNECTED, "tSDP_STATE::CONNECTED(0x3)"),

      std::make_pair(tSDP_STATE::CONN_PEND, "tSDP_STATE::CONN_PEND(0x4)"),

  };

  for (const auto& state : states) {

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