RFCOMM: Replace rfc.state with rfc.sm_cb.state am: f494b46657 am: 3f65c51171

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

Change-Id: I02daaea2dd67c01860681eab67e0b76b16920a1b
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

8 files changed, 69 insertions, 52 deletions

diff --git a/system/stack/rfcomm/port_api.cc b/system/stack/rfcomm/port_api.cc
index d74d4d1835..1711051b86 100644
--- a/system/stack/rfcomm/port_api.cc
+++ b/system/stack/rfcomm/port_api.cc
@@ -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;
diff --git a/system/stack/rfcomm/port_int.h b/system/stack/rfcomm/port_int.h
index 94d9f4cc8b..f79310d90b 100644
--- a/system/stack/rfcomm/port_int.h
+++ b/system/stack/rfcomm/port_int.h
@@ -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 */
@@ -104,10 +105,22 @@ typedef struct {
 } 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
diff --git a/system/stack/rfcomm/port_rfc.cc b/system/stack/rfcomm/port_rfc.cc
index a4cf8d5adf..e7813a240f 100644
--- a/system/stack/rfcomm/port_rfc.cc
+++ b/system/stack/rfcomm/port_rfc.cc
@@ -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={}[{}], "
diff --git a/system/stack/rfcomm/port_utils.cc b/system/stack/rfcomm/port_utils.cc
index 25e1da9f4c..dc59e58987 100644
--- a/system/stack/rfcomm/port_utils.cc
+++ b/system/stack/rfcomm/port_utils.cc
@@ -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);
diff --git a/system/stack/rfcomm/rfc_port_fsm.cc b/system/stack/rfcomm/rfc_port_fsm.cc
index 0f3ec064ff..040315d276 100644
--- a/system/stack/rfcomm/rfc_port_fsm.cc
+++ b/system/stack/rfcomm/rfc_port_fsm.cc
@@ -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));
diff --git a/system/stack/rfcomm/rfc_port_if.cc b/system/stack/rfcomm/rfc_port_if.cc
index 0973f0370a..af6906fbb5 100644
--- a/system/stack/rfcomm/rfc_port_if.cc
+++ b/system/stack/rfcomm/rfc_port_if.cc
@@ -257,7 +257,8 @@ void RFCOMM_ControlReq(tRFC_MCB* p_mcb, uint8_t dlci, tPORT_CTRL* p_pars) {
     return;
   }
 
-  if ((p_port->state != PORT_CONNECTION_STATE_OPENED) || (p_port->rfc.state != RFC_STATE_OPENED)) {
+  if ((p_port->state != PORT_CONNECTION_STATE_OPENED) ||
+      (p_port->rfc.sm_cb.state != RFC_STATE_OPENED)) {
     return;
   }
 
@@ -285,7 +286,8 @@ void RFCOMM_FlowReq(tRFC_MCB* p_mcb, uint8_t dlci, bool enable) {
     return;
   }
 
-  if ((p_port->state != PORT_CONNECTION_STATE_OPENED) || (p_port->rfc.state != RFC_STATE_OPENED)) {
+  if ((p_port->state != PORT_CONNECTION_STATE_OPENED) ||
+      (p_port->rfc.sm_cb.state != RFC_STATE_OPENED)) {
     return;
   }
 
@@ -312,7 +314,8 @@ void RFCOMM_LineStatusReq(tRFC_MCB* p_mcb, uint8_t dlci, uint8_t status) {
     return;
   }
 
-  if ((p_port->state != PORT_CONNECTION_STATE_OPENED) || (p_port->rfc.state != RFC_STATE_OPENED)) {
+  if ((p_port->state != PORT_CONNECTION_STATE_OPENED) ||
+      (p_port->rfc.sm_cb.state != RFC_STATE_OPENED)) {
     return;
   }
 
diff --git a/system/stack/rfcomm/rfc_utils.cc b/system/stack/rfcomm/rfc_utils.cc
index 55c30bb604..55845a9f76 100644
--- a/system/stack/rfcomm/rfc_utils.cc
+++ b/system/stack/rfcomm/rfc_utils.cc
@@ -319,8 +319,8 @@ void rfc_sec_check_complete(RawAddress /* bd_addr */, tBT_TRANSPORT /* transport
   tPORT* p_port = (tPORT*)p_ref_data;
 
   /* Verify that PORT is still waiting for Security to complete */
-  if (!p_port->in_use || ((p_port->rfc.state != RFC_STATE_ORIG_WAIT_SEC_CHECK) &&
-                          (p_port->rfc.state != RFC_STATE_TERM_WAIT_SEC_CHECK))) {
+  if (!p_port->in_use || ((p_port->rfc.sm_cb.state != RFC_STATE_ORIG_WAIT_SEC_CHECK) &&
+                          (p_port->rfc.sm_cb.state != RFC_STATE_TERM_WAIT_SEC_CHECK))) {
     return;
   }
 
@@ -341,7 +341,7 @@ void rfc_sec_check_complete(RawAddress /* bd_addr */, tBT_TRANSPORT /* transport
 void rfc_port_closed(tPORT* p_port) {
   tRFC_MCB* p_mcb = p_port->rfc.p_mcb;
   rfc_port_timer_stop(p_port);
-  p_port->rfc.state = RFC_STATE_CLOSED;
+  p_port->rfc.sm_cb.state = RFC_STATE_CLOSED;
 
   /* If multiplexer channel was up mark it as down */
   if (p_mcb) {
diff --git a/system/stack/test/rfcomm/stack_rfcomm_port_test.cc b/system/stack/test/rfcomm/stack_rfcomm_port_test.cc
index 54ca9943b6..084e109c72 100644
--- a/system/stack/test/rfcomm/stack_rfcomm_port_test.cc
+++ b/system/stack/test/rfcomm/stack_rfcomm_port_test.cc
@@ -48,9 +48,9 @@ TEST_F(StackRfcommPortTest, PORT_IsOpening__basic) {
   ASSERT_TRUE(PORT_IsOpening(&bd_addr));
   rfc_cb.port.rfc_mcb[0].state = RFC_MX_STATE_CONNECTED;
   rfc_cb.port.port[0].rfc.p_mcb = &rfc_cb.port.rfc_mcb[0];
-  rfc_cb.port.port[0].rfc.state = RFC_STATE_OPENED;
+  rfc_cb.port.port[0].rfc.sm_cb.state = RFC_STATE_OPENED;
   ASSERT_FALSE(PORT_IsOpening(&bd_addr));
-  rfc_cb.port.port[0].rfc.state = RFC_STATE_TERM_WAIT_SEC_CHECK;
+  rfc_cb.port.port[0].rfc.sm_cb.state = RFC_STATE_TERM_WAIT_SEC_CHECK;
   ASSERT_TRUE(PORT_IsOpening(&bd_addr));
   rfc_cb.port.rfc_mcb[0].state = RFC_MX_STATE_DISC_WAIT_UA;
   ASSERT_FALSE(PORT_IsOpening(&bd_addr));
@@ -90,9 +90,9 @@ TEST_F(StackRfcommPortTest, PORT_IsCollisionDetected__basic) {
   rfc_cb.port.rfc_mcb[0].state = RFC_MX_STATE_CONNECTED;
 
   rfc_cb.port.port[0].rfc.p_mcb = &rfc_cb.port.rfc_mcb[0];
-  rfc_cb.port.port[0].rfc.state = RFC_STATE_OPENED;
+  rfc_cb.port.port[0].rfc.sm_cb.state = RFC_STATE_OPENED;
   ASSERT_FALSE(PORT_IsCollisionDetected(test_bd_addr));
-  rfc_cb.port.port[0].rfc.state = RFC_STATE_TERM_WAIT_SEC_CHECK;
+  rfc_cb.port.port[0].rfc.sm_cb.state = RFC_STATE_TERM_WAIT_SEC_CHECK;
   ASSERT_TRUE(PORT_IsCollisionDetected(test_bd_addr));
   rfc_cb.port.rfc_mcb[0].state = RFC_MX_STATE_DISC_WAIT_UA;
   ASSERT_FALSE(PORT_IsCollisionDetected(test_bd_addr));