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

Commit f494b466 authored by Pomai Ahlo's avatar Pomai Ahlo
Browse files

RFCOMM: Replace rfc.state with rfc.sm_cb.state 

Introduce new state machine control block to hold port state.  Move port
state to sm_cb and change all references to reflect accordingly.

Bug: 361844445
Test: m Bluetooth
Flag: EXEMPT Mechanical Refactor
Change-Id: I8d4467f4deb63f1befa3097ddcd244a76042172b
parent 90d4767b

system/stack/rfcomm/port_api.cc

+10 −10
Original line number Diff line number Diff line
@@ -142,7 +142,7 @@ int RFCOMM_CreateConnectionWithSecurity(uint16_t uuid, uint8_t scn, bool is_serv 
        log::error(

                "already at opened state {}, RFC_state={}, MCB_state={}, "

                "bd_addr={}, scn={}, is_server={}, mtu={}, uuid=0x{:x}, dlci={}, p_mcb={}, port={}",

                static_cast<int>(p_port->state), static_cast<int>(p_port->rfc.state),

                static_cast<int>(p_port->state), static_cast<int>(p_port->rfc.sm_cb.state),

                p_port->rfc.p_mcb ? p_port->rfc.p_mcb->state : 0, bd_addr, scn, is_server, mtu,

                uuid, dlci, std::format_ptr(p_mcb), p_port->handle);

        *p_handle = p_port->handle;
@@ -455,14 +455,14 @@ int PORT_CheckConnection(uint16_t handle, RawAddress* bd_addr, uint16_t* p_lcid) 
  }

  log::verbose("handle={}, in_use={}, port_state={}, p_mcb={}, peer_ready={}, rfc_state={}", handle,

               p_port->in_use, p_port->state, std::format_ptr(p_port->rfc.p_mcb),

               p_port->rfc.p_mcb ? p_port->rfc.p_mcb->peer_ready : -1, p_port->rfc.state);

               p_port->rfc.p_mcb ? p_port->rfc.p_mcb->peer_ready : -1, p_port->rfc.sm_cb.state);



  if (!p_port->in_use || (p_port->state == PORT_CONNECTION_STATE_CLOSED)) {

    return PORT_NOT_OPENED;

  }



  if (!p_port->rfc.p_mcb || !p_port->rfc.p_mcb->peer_ready ||

      (p_port->rfc.state != RFC_STATE_OPENED)) {

      (p_port->rfc.sm_cb.state != RFC_STATE_OPENED)) {

    return PORT_LINE_ERR;

  }
@@ -509,8 +509,8 @@ bool PORT_IsOpening(RawAddress* bd_addr) { 
    if (multiplexer_cb.state == RFC_MX_STATE_CONNECTED) {

      const tPORT* p_port = get_port_from_mcb(&multiplexer_cb);

      log::info("RFC_MX_STATE_CONNECTED, found_port={}, tRFC_PORT_STATE={}",

                (p_port != nullptr) ? "T" : "F", (p_port != nullptr) ? p_port->rfc.state : 0);

      if ((p_port == nullptr) || (p_port->rfc.state < RFC_STATE_OPENED)) {

                (p_port != nullptr) ? "T" : "F", (p_port != nullptr) ? p_port->rfc.sm_cb.state : 0);

      if ((p_port == nullptr) || (p_port->rfc.sm_cb.state < RFC_STATE_OPENED)) {

        /* Port is not established yet. */

        *bd_addr = multiplexer_cb.bd_addr;

        log::info("In RFC_MX_STATE_CONNECTED but port is not established yet, returning true");
@@ -554,8 +554,8 @@ bool PORT_IsCollisionDetected(RawAddress bd_addr) { 
    if (multiplexer_cb.state == RFC_MX_STATE_CONNECTED) {

      const tPORT* p_port = get_port_from_mcb(&multiplexer_cb);

      log::info("RFC_MX_STATE_CONNECTED, found_port={}, tRFC_PORT_STATE={}",

                (p_port != nullptr) ? "T" : "F", (p_port != nullptr) ? p_port->rfc.state : 0);

      if ((p_port == nullptr) || (p_port->rfc.state < RFC_STATE_OPENED)) {

                (p_port != nullptr) ? "T" : "F", (p_port != nullptr) ? p_port->rfc.sm_cb.state : 0);

      if ((p_port == nullptr) || (p_port->rfc.sm_cb.state < RFC_STATE_OPENED)) {

        // Port is not established yet

        log::info(

                "In RFC_MX_STATE_CONNECTED but port is not established yet, "
@@ -828,7 +828,7 @@ int PORT_ReadData(uint16_t handle, char* p_data, uint16_t max_len, uint16_t* p_l 
static int port_write(tPORT* p_port, BT_HDR* p_buf) {

  /* We should not allow to write data in to server port when connection is not

   * opened */

  if (p_port->is_server && (p_port->rfc.state != RFC_STATE_OPENED)) {

  if (p_port->is_server && (p_port->rfc.sm_cb.state != RFC_STATE_OPENED)) {

    osi_free(p_buf);

    return PORT_CLOSED;

  }
@@ -837,7 +837,7 @@ static int port_write(tPORT* p_port, BT_HDR* p_buf) { 
  /* Peer is not ready or Port is not yet opened or initial port control */

  /* command has not been sent */

  if (p_port->tx.peer_fc || !p_port->rfc.p_mcb || !p_port->rfc.p_mcb->peer_ready ||

      (p_port->rfc.state != RFC_STATE_OPENED) ||

      (p_port->rfc.sm_cb.state != RFC_STATE_OPENED) ||

      ((p_port->port_ctrl & (PORT_CTRL_REQ_SENT | PORT_CTRL_IND_RECEIVED)) !=

       (PORT_CTRL_REQ_SENT | PORT_CTRL_IND_RECEIVED))) {

    if ((p_port->tx.queue_size > PORT_TX_CRITICAL_WM) ||
@@ -857,7 +857,7 @@ static int port_write(tPORT* p_port, BT_HDR* p_buf) { 
            "Data is enqueued. flow disabled {} peer_ready {} state {} ctrl_state "

            "{:x}",

            p_port->tx.peer_fc, p_port->rfc.p_mcb && p_port->rfc.p_mcb->peer_ready,

            p_port->rfc.state, p_port->port_ctrl);

            p_port->rfc.sm_cb.state, p_port->port_ctrl);



    fixed_queue_enqueue(p_port->tx.queue, p_buf);

    p_port->tx.queue_size += p_buf->len;

system/stack/rfcomm/port_int.h

+15 −2
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
#include "stack/include/l2cap_types.h"

#include "stack/include/port_api.h"

#include "stack/include/rfcdefs.h"

#include "stack/rfcomm/rfc_event.h"

#include "stack/rfcomm/rfc_state.h"

#include "types/raw_address.h"
@@ -45,7 +46,7 @@ 
#define PORT_FC_CREDIT 2    /* use RFCOMM credit based flow control */



/*

 * Define Port Data Transfere control block

 * Define Port Data Transfer control block

 */

typedef struct {

  fixed_queue_t* queue;       /* Queue of buffers waiting to be sent */
@@ -103,11 +104,23 @@ typedef struct { 
                                         connection while connecting */

} tRFC_MCB;



/*

 * RFCOMM Port State Machine Control Block

 */

struct RfcommPortSm {

  tRFC_PORT_STATE state;

  tRFC_PORT_STATE state_prior;

  tRFC_PORT_EVENT last_event;

  tPORT_RESULT close_reason;

  uint64_t open_timestamp;

  uint64_t close_timestamp;

};



/*

 * RFCOMM Port Connection Control Block

 */

typedef struct {

  tRFC_PORT_STATE state; /* Current state of the connection */

  RfcommPortSm sm_cb;  // State machine control block



#define RFC_RSP_PN 0x01

#define RFC_RSP_RPN_REPLY 0x02

system/stack/rfcomm/port_rfc.cc

+4 −4
Original line number Diff line number Diff line
@@ -180,7 +180,7 @@ void port_start_close(tPORT* p_port) { 
  }



  /* Check if RFCOMM side has been closed while the message was queued */

  if ((p_mcb == NULL) || (p_port->rfc.state == RFC_STATE_CLOSED)) {

  if ((p_mcb == NULL) || (p_port->rfc.sm_cb.state == RFC_STATE_CLOSED)) {

    /* Call management callback function before calling port_release_port() to

     * clear tPort */

    if (p_port->p_mgmt_callback) {
@@ -899,7 +899,7 @@ void PORT_FlowInd(tRFC_MCB* p_mcb, uint8_t dlci, bool enable_data) { 
    if (dlci == 0) {

      p_port = &rfc_cb.port.port[i];

      if (!p_port->in_use || (p_port->rfc.p_mcb != p_mcb) ||

          (p_port->rfc.state != RFC_STATE_OPENED)) {

          (p_port->rfc.sm_cb.state != RFC_STATE_OPENED)) {

        continue;

      }

    }
@@ -991,7 +991,7 @@ void port_rfc_closed(tPORT* p_port, uint8_t res) { 
    log::warn("port_rfc_closed in OPENING state ignored");



    rfc_port_timer_stop(p_port);

    p_port->rfc.state = RFC_STATE_CLOSED;

    p_port->rfc.sm_cb.state = RFC_STATE_CLOSED;



    if (p_mcb) {

      p_mcb->port_handles[p_port->dlci] = 0;
@@ -1049,7 +1049,7 @@ void port_rfc_closed(tPORT* p_port, uint8_t res) { 
    p_port->p_mgmt_callback(static_cast<tPORT_RESULT>(res2), p_port->handle);

  }



  p_port->rfc.state = RFC_STATE_CLOSED;

  p_port->rfc.sm_cb.state = RFC_STATE_CLOSED;



  log::info(

          "RFCOMM connection closed, index={}, state={}, reason={}[{}], "

system/stack/rfcomm/port_utils.cc

+4 −3
Original line number Diff line number Diff line
@@ -199,8 +199,8 @@ void port_select_mtu(tPORT* p_port) { 
 *

 ******************************************************************************/

void port_release_port(tPORT* p_port) {

  log::verbose("p_port: {} state: {} keep_handle: {}", std::format_ptr(p_port), p_port->rfc.state,

               p_port->keep_port_handle);

  log::verbose("p_port: {} state: {} keep_handle: {}", std::format_ptr(p_port),

               p_port->rfc.sm_cb.state, p_port->keep_port_handle);



  mutex_global_lock();

  BT_HDR* p_buf;
@@ -219,7 +219,7 @@ void port_release_port(tPORT* p_port) { 


  p_port->state = PORT_CONNECTION_STATE_CLOSED;



  if (p_port->rfc.state == RFC_STATE_CLOSED) {

  if (p_port->rfc.sm_cb.state == RFC_STATE_CLOSED) {

    if (p_port->rfc.p_mcb) {

      p_port->rfc.p_mcb->port_handles[p_port->dlci] = 0;
@@ -228,6 +228,7 @@ void port_release_port(tPORT* p_port) { 
    }



    rfc_port_timer_stop(p_port);

    p_port->rfc.sm_cb = {};



    mutex_global_lock();

    fixed_queue_free(p_port->tx.queue, nullptr);

system/stack/rfcomm/rfc_port_fsm.cc

+23 −23
Original line number Diff line number Diff line
@@ -77,11 +77,11 @@ void rfc_port_sm_execute(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data) { 
  log::assert_that(p_port != nullptr, "NULL port event {}", event);



  // logs for state RFC_STATE_OPENED handled in rfc_port_sm_opened()

  if (p_port->rfc.state != RFC_STATE_OPENED) {

  if (p_port->rfc.sm_cb.state != RFC_STATE_OPENED) {

    log::info("bd_addr:{}, handle:{}, state:{}, event:{}", p_port->bd_addr, p_port->handle,

              rfcomm_port_state_text(p_port->rfc.state), rfcomm_port_event_text(event));

              rfcomm_port_state_text(p_port->rfc.sm_cb.state), rfcomm_port_event_text(event));

  }

  switch (p_port->rfc.state) {

  switch (p_port->rfc.sm_cb.state) {

    case RFC_STATE_CLOSED:

      rfc_port_sm_state_closed(p_port, event, p_data);

      break;
@@ -122,7 +122,7 @@ void rfc_port_sm_execute(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data) { 
void rfc_port_sm_state_closed(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data) {

  switch (event) {

    case RFC_PORT_EVENT_OPEN:

      p_port->rfc.state = RFC_STATE_ORIG_WAIT_SEC_CHECK;

      p_port->rfc.sm_cb.state = RFC_STATE_ORIG_WAIT_SEC_CHECK;

      btm_sec_mx_access_request(p_port->rfc.p_mcb->bd_addr, true, p_port->sec_mask,

                                &rfc_sec_check_complete, p_port);

      return;
@@ -143,7 +143,7 @@ void rfc_port_sm_state_closed(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data 
      rfc_timer_stop(p_port->rfc.p_mcb);



      /* Open will be continued after security checks are passed */

      p_port->rfc.state = RFC_STATE_TERM_WAIT_SEC_CHECK;

      p_port->rfc.sm_cb.state = RFC_STATE_TERM_WAIT_SEC_CHECK;

      btm_sec_mx_access_request(p_port->rfc.p_mcb->bd_addr, false, p_port->sec_mask,

                                &rfc_sec_check_complete, p_port);

      return;
@@ -167,11 +167,11 @@ void rfc_port_sm_state_closed(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data 


    case RFC_PORT_EVENT_TIMEOUT:

      PORT_TimeOutCloseMux(p_port->rfc.p_mcb);

      log::error("Port error state {} event {}", p_port->rfc.state, event);

      log::error("Port error state {} event {}", p_port->rfc.sm_cb.state, event);

      return;

    default:

      log::error("Received unexpected event:{} in state:{}", rfcomm_port_event_text(event),

                 rfcomm_port_state_text(p_port->rfc.state));

                 rfcomm_port_state_text(p_port->rfc.sm_cb.state));

  }



  log::warn("Event ignored {}", rfcomm_port_event_text(event));
@@ -199,7 +199,7 @@ void rfc_port_sm_sabme_wait_ua(tPORT* p_port, tRFC_PORT_EVENT event, void* p_dat 
      rfc_port_timer_start(p_port, RFC_DISC_TIMEOUT);

      rfc_send_disc(p_port->rfc.p_mcb, p_port->dlci);

      p_port->rfc.expected_rsp = 0;

      p_port->rfc.state = RFC_STATE_DISC_WAIT_UA;

      p_port->rfc.sm_cb.state = RFC_STATE_DISC_WAIT_UA;

      return;



    case RFC_PORT_EVENT_CLEAR:
@@ -213,7 +213,7 @@ void rfc_port_sm_sabme_wait_ua(tPORT* p_port, tRFC_PORT_EVENT event, void* p_dat 


    case RFC_PORT_EVENT_UA:

      rfc_port_timer_stop(p_port);

      p_port->rfc.state = RFC_STATE_OPENED;

      p_port->rfc.sm_cb.state = RFC_STATE_OPENED;



      if (uuid_logging_acceptlist.find(p_port->uuid) != uuid_logging_acceptlist.end()) {

        // Find Channel Control Block by Channel ID
@@ -267,13 +267,13 @@ void rfc_port_sm_sabme_wait_ua(tPORT* p_port, tRFC_PORT_EVENT event, void* p_dat 
      return;



    case RFC_PORT_EVENT_TIMEOUT:

      p_port->rfc.state = RFC_STATE_CLOSED;

      p_port->rfc.sm_cb.state = RFC_STATE_CLOSED;

      PORT_DlcEstablishCnf(p_port->rfc.p_mcb, p_port->dlci, p_port->rfc.p_mcb->peer_l2cap_mtu,

                           RFCOMM_ERROR);

      return;

    default:

      log::error("Received unexpected event:{} in state:{}", rfcomm_port_event_text(event),

                 rfcomm_port_state_text(static_cast<tRFC_PORT_STATE>(p_port->rfc.state)));

                 rfcomm_port_state_text(static_cast<tRFC_PORT_STATE>(p_port->rfc.sm_cb.state)));

  }

  log::warn("Event ignored {}", rfcomm_port_event_text(event));

}
@@ -296,7 +296,7 @@ void rfc_port_sm_term_wait_sec_check(tPORT* p_port, tRFC_PORT_EVENT event, void* 
      if (*((tBTM_STATUS*)p_data) != tBTM_STATUS::BTM_SUCCESS) {

        log::error("Security check failed result:{} state:{} port_handle:{}",

                   btm_status_text(*((tBTM_STATUS*)p_data)),

                   rfcomm_port_state_text(p_port->rfc.state), p_port->handle);

                   rfcomm_port_state_text(p_port->rfc.sm_cb.state), p_port->handle);

        /* Authentication/authorization failed.  If link is still  */

        /* up send DM and check if we need to start inactive timer */

        if (p_port->rfc.p_mcb) {
@@ -306,7 +306,7 @@ void rfc_port_sm_term_wait_sec_check(tPORT* p_port, tRFC_PORT_EVENT event, void* 
        }

      } else {

        log::debug("Security check succeeded state:{} port_handle:{}",

                   rfcomm_port_state_text(static_cast<tRFC_PORT_STATE>(p_port->rfc.state)),

                   rfcomm_port_state_text(static_cast<tRFC_PORT_STATE>(p_port->rfc.sm_cb.state)),

                   p_port->handle);

        PORT_DlcEstablishInd(p_port->rfc.p_mcb, p_port->dlci, p_port->rfc.p_mcb->peer_l2cap_mtu);

      }
@@ -334,7 +334,7 @@ void rfc_port_sm_term_wait_sec_check(tPORT* p_port, tRFC_PORT_EVENT event, void* 


    case RFC_PORT_EVENT_DISC:

      btm_sec_abort_access_req(p_port->rfc.p_mcb->bd_addr);

      p_port->rfc.state = RFC_STATE_CLOSED;

      p_port->rfc.sm_cb.state = RFC_STATE_CLOSED;

      rfc_send_ua(p_port->rfc.p_mcb, p_port->dlci);



      PORT_DlcReleaseInd(p_port->rfc.p_mcb, p_port->dlci);
@@ -351,7 +351,7 @@ void rfc_port_sm_term_wait_sec_check(tPORT* p_port, tRFC_PORT_EVENT event, void* 
        }

      } else {

        rfc_send_ua(p_port->rfc.p_mcb, p_port->dlci);

        p_port->rfc.state = RFC_STATE_OPENED;

        p_port->rfc.sm_cb.state = RFC_STATE_OPENED;



        if (uuid_logging_acceptlist.find(p_port->uuid) != uuid_logging_acceptlist.end()) {

          // Find Channel Control Block by Channel ID
@@ -378,7 +378,7 @@ void rfc_port_sm_term_wait_sec_check(tPORT* p_port, tRFC_PORT_EVENT event, void* 
      return;

    default:

      log::error("Received unexpected event:{} in state:{}", rfcomm_port_event_text(event),

                 rfcomm_port_state_text(p_port->rfc.state));

                 rfcomm_port_state_text(p_port->rfc.sm_cb.state));

  }

  log::warn("Event ignored {}", event);

}
@@ -400,16 +400,16 @@ void rfc_port_sm_orig_wait_sec_check(tPORT* p_port, tRFC_PORT_EVENT event, void* 
      if (*((tBTM_STATUS*)p_data) != tBTM_STATUS::BTM_SUCCESS) {

        log::error("Security check failed result:{} state:{} handle:{}",

                   btm_status_text(*((tBTM_STATUS*)p_data)),

                   rfcomm_port_state_text(p_port->rfc.state), p_port->handle);

                   rfcomm_port_state_text(p_port->rfc.sm_cb.state), p_port->handle);

        p_port->rfc.p_mcb->is_disc_initiator = true;

        PORT_DlcEstablishCnf(p_port->rfc.p_mcb, p_port->dlci, 0, RFCOMM_SECURITY_ERR);

        rfc_port_closed(p_port);

      } else {

        log::debug("Security check succeeded state:{} handle:{}",

                   rfcomm_port_state_text(p_port->rfc.state), p_port->handle);

                   rfcomm_port_state_text(p_port->rfc.sm_cb.state), p_port->handle);

        rfc_send_sabme(p_port->rfc.p_mcb, p_port->dlci);

        rfc_port_timer_start(p_port, RFC_PORT_T1_TIMEOUT);

        p_port->rfc.state = RFC_STATE_SABME_WAIT_UA;

        p_port->rfc.sm_cb.state = RFC_STATE_SABME_WAIT_UA;

      }

      return;
@@ -434,7 +434,7 @@ void rfc_port_sm_orig_wait_sec_check(tPORT* p_port, tRFC_PORT_EVENT event, void* 
      return;

    default:

      log::error("Received unexpected event:{} in state:{}", rfcomm_port_event_text(event),

                 rfcomm_port_state_text(p_port->rfc.state));

                 rfcomm_port_state_text(p_port->rfc.sm_cb.state));

  }

  log::warn("Event ignored {}", rfcomm_port_event_text(event));

}
@@ -462,7 +462,7 @@ void rfc_port_sm_opened(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data) { 
      rfc_port_timer_start(p_port, RFC_DISC_TIMEOUT);

      rfc_send_disc(p_port->rfc.p_mcb, p_port->dlci);

      p_port->rfc.expected_rsp = 0;

      p_port->rfc.state = RFC_STATE_DISC_WAIT_UA;

      p_port->rfc.sm_cb.state = RFC_STATE_DISC_WAIT_UA;

      return;



    case RFC_PORT_EVENT_CLEAR:
@@ -510,7 +510,7 @@ void rfc_port_sm_opened(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data) { 
    case RFC_PORT_EVENT_DISC:

      log::info("RFC_PORT_EVENT_DISC bd_addr:{} handle:{} dlci:{} scn:{}", p_port->bd_addr,

                p_port->handle, p_port->dlci, p_port->scn);

      p_port->rfc.state = RFC_STATE_CLOSED;

      p_port->rfc.sm_cb.state = RFC_STATE_CLOSED;

      rfc_send_ua(p_port->rfc.p_mcb, p_port->dlci);

      if (!fixed_queue_is_empty(p_port->rx.queue)) {

        /* give a chance to upper stack to close port properly */
@@ -607,7 +607,7 @@ void rfc_port_sm_disc_wait_ua(tPORT* p_port, tRFC_PORT_EVENT event, void* p_data 
      return;

    default:

      log::error("Received unexpected event:{} in state:{}", rfcomm_port_event_text(event),

                 rfcomm_port_state_text(p_port->rfc.state));

                 rfcomm_port_state_text(p_port->rfc.sm_cb.state));

  }



  log::warn("Event ignored {}", rfcomm_port_event_text(event));