Implement missing HDLC ABM protocol features

Add DM (Disconnect Mode) frame support:
- Send DM response when I/S-frames arrive in disconnected state
  instead of auto-reconnecting with SABM (per ISO 13239)
- Handle incoming DM frames by transitioning to disconnected state

Complete FRMR (Frame Reject) handler:
- On FRMR reception, disconnect and initiate link reset via SABM

Implement RSET (Reset) handler:
- Reset sequence numbers (V(S), V(R)) on RSET reception
- Respond with UA frame as required by spec

Add RNR (Receive Not Ready) S-frame recognition:
- Confirm frames up to N(R) but do not trigger further sends
- Enables peer busy flow control signaling

Update proto logger to recognize DM and RNR frame subtypes.

Update and expand unit tests:
- Rename ABM_SendSABMOnIFrameIfDisconnected to ABM_SendDMOnIFrameIfDisconnected
- Add ABM_SendDMOnSFrameIfDisconnected
- Add ABM_FRMRReceiveTriggersReconnect
- Add ABM_RSETResetsSequenceNumbers
- Add ABM_RNRPausesTransmission
- Add ABM_DMReceiveDisconnects

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: lexus2k

src/proto/fd/tiny_fd.c

@@ -147,19 +147,15 @@ static void on_frame_read(void *user_data, uint8_t *data, int len)
     {
         __on_u_frame_read(handle, peer, data, len);
     }
-    // If I-frame is received when connection is not established, we should ignore it
-    // And let's attempt to initiate new connection
+    // If I-frame is received when connection is not established, send DM per HDLC ABM spec
     else if ( handle->peers[peer].state != TINY_FD_STATE_CONNECTED && handle->peers[peer].state != TINY_FD_STATE_DISCONNECTING )
     {
-        // Should send DM in case we receive here S- or I-frames.
-        // If connection is not established, we should ignore all frames except U-frames
-        LOG(TINY_LOG_CRIT, "[%p] Connection is not established, connecting\n", handle);
+        LOG(TINY_LOG_CRIT, "[%p] Connection is not established, sending DM\n", handle);
         tiny_frame_header_t frame = {
-            .address = __peer_to_address_field( handle, peer ) | HDLC_CR_BIT,
-            .control = (handle->mode == TINY_FD_MODE_NRM ? HDLC_U_FRAME_TYPE_SNRM : HDLC_U_FRAME_TYPE_SABM) | HDLC_U_FRAME_BITS,
+            .address = __peer_to_address_field( handle, peer ),
+            .control = HDLC_U_FRAME_TYPE_DM | HDLC_U_FRAME_BITS,
         };
         __put_u_s_frame_to_tx_queue(handle, TINY_FD_QUEUE_U_FRAME, &frame, 2);
-        handle->peers[peer].state = TINY_FD_STATE_CONNECTING;
     }
     else if ( (control & HDLC_I_FRAME_MASK) == HDLC_I_FRAME_BITS )
     {

src/proto/fd/tiny_fd.h

@@ -107,9 +107,11 @@ extern "C"
     typedef enum
     {
         TINY_FD_FRAME_SUBTYPE_RR = 0x00, ///< S-frame subtype RR
+        TINY_FD_FRAME_SUBTYPE_RNR = 0x04, ///< S-frame subtype RNR
         TINY_FD_FRAME_SUBTYPE_REJ = 0x08, ///< S-frame subtype REJ
 
         TINY_FD_FRAME_SUBTYPE_UA = 0x60, ///< U-frame subtype UA
+        TINY_FD_FRAME_SUBTYPE_DM = 0x0C, ///< U-frame subtype DM
         TINY_FD_FRAME_SUBTYPE_FRMR = 0x84, ///< U-frame subtype FRMR
         TINY_FD_FRAME_SUBTYPE_RSET = 0x8C, ///< U-frame subtype RSET
         TINY_FD_FRAME_SUBTYPE_SABM = 0x2C, ///< U-frame subtype SABM

src/proto/fd/tiny_fd_defines_int.h

@@ -89,12 +89,14 @@ enum
 #define HDLC_S_FRAME_MASK 0x03
 #define HDLC_S_FRAME_TYPE_REJ 0x08
 #define HDLC_S_FRAME_TYPE_RR 0x00
+#define HDLC_S_FRAME_TYPE_RNR 0x04
 #define HDLC_S_FRAME_TYPE_MASK 0x0C
 
 #define HDLC_U_FRAME_BITS 0x03
 #define HDLC_U_FRAME_MASK 0x03
 // 2 lower bits of the command id's are zero, because they are covered by U_FRAME_BITS
 #define HDLC_U_FRAME_TYPE_UA 0x60
+#define HDLC_U_FRAME_TYPE_DM 0x0C
 #define HDLC_U_FRAME_TYPE_FRMR 0x84
 #define HDLC_U_FRAME_TYPE_RSET 0x8C
 #define HDLC_U_FRAME_TYPE_SABM 0x2C

src/proto/fd/tiny_fd_on_rx_int.h

@@ -123,7 +123,7 @@ static int __on_s_frame_read(tiny_fd_handle_t handle, uint8_t peer, void *data,
     uint8_t nr = control >> 5;
     int result = TINY_ERR_FAILED;
     LOG(TINY_LOG_INFO, "[%p] Receiving S-Frame N(R)=%02X, type=%s with address [%02X]\n", handle, nr,
-        ((control >> 2) & 0x03) == 0x00 ? "RR" : "REJ", ((uint8_t *)data)[0]);
+        ((control >> 2) & 0x03) == 0x00 ? "RR" : ((control >> 2) & 0x03) == 0x01 ? "RNR" : "REJ", ((uint8_t *)data)[0]);
     if ( (control & HDLC_S_FRAME_TYPE_MASK) == HDLC_S_FRAME_TYPE_REJ )
     {
         // Confirm all previously sent frames up to received N(R)
@@ -148,6 +148,12 @@ static int __on_s_frame_read(tiny_fd_handle_t handle, uint8_t peer, void *data,
             }
         }
     }
+    else if ( (control & HDLC_S_FRAME_TYPE_MASK) == HDLC_S_FRAME_TYPE_RNR )
+    {
+        // Confirm all previously sent frames up to received N(R), but peer is busy — do not send more
+        __confirm_sent_frames(handle, peer, nr);
+        LOG(TINY_LOG_WRN, "[%p] Peer signalled RNR (busy), pausing I-frame transmission\n", handle);
+    }
     return result;
 }
 
@@ -183,13 +189,31 @@ static int __on_u_frame_read(tiny_fd_handle_t handle, uint8_t peer, void *data,
     }
     else if ( type == HDLC_U_FRAME_TYPE_RSET )
     {
-        // resets N(R) = 0 in secondary, resets N(S) = 0 in primary
-        // expected answer UA
+        // RSET resets sequence numbers and expects UA response
+        LOG(TINY_LOG_WRN, "[%p] RSET received, resetting sequence numbers\n", handle);
+        __reset_i_queue_control(&handle->peers[peer].i_queue_control);
+        handle->peers[peer].sent_nr = 0;
+        handle->peers[peer].sent_reject = 0;
+        tiny_frame_header_t frame = {
+            .address = __peer_to_address_field( handle, peer ),
+            .control = HDLC_U_FRAME_TYPE_UA | HDLC_U_FRAME_BITS,
+        };
+        __put_u_s_frame_to_tx_queue(handle, TINY_FD_QUEUE_U_FRAME, &frame, 2);
     }
     else if ( type == HDLC_U_FRAME_TYPE_FRMR )
     {
-        // response of secondary in case of protocol errors: invalid control field, invalid N(R),
-        // information field too long or not expected in this frame
+        // FRMR indicates protocol error on remote side — initiate link reset via SABM/SNRM
+        LOG(TINY_LOG_ERR, "[%p] FRMR received, initiating link reset\n", handle);
+        if ( handle->peers[peer].state != TINY_FD_STATE_DISCONNECTED )
+        {
+            __switch_to_disconnected_state(handle, peer);
+        }
+        tiny_frame_header_t sabm_frame = {
+            .address = __peer_to_address_field( handle, peer ) | HDLC_CR_BIT,
+            .control = (handle->mode == TINY_FD_MODE_NRM ? HDLC_U_FRAME_TYPE_SNRM : HDLC_U_FRAME_TYPE_SABM) | HDLC_U_FRAME_BITS,
+        };
+        __put_u_s_frame_to_tx_queue(handle, TINY_FD_QUEUE_U_FRAME, &sabm_frame, 2);
+        handle->peers[peer].state = TINY_FD_STATE_CONNECTING;
     }
     else if ( type == HDLC_U_FRAME_TYPE_UA )
     {
@@ -203,6 +227,15 @@ static int __on_u_frame_read(tiny_fd_handle_t handle, uint8_t peer, void *data,
             __switch_to_disconnected_state(handle, peer);
         }
     }
+    else if ( type == HDLC_U_FRAME_TYPE_DM )
+    {
+        // DM indicates the remote side is in disconnected mode
+        LOG(TINY_LOG_WRN, "[%p] DM received, peer is in disconnected mode\n", handle);
+        if ( handle->peers[peer].state != TINY_FD_STATE_DISCONNECTED )
+        {
+            __switch_to_disconnected_state(handle, peer);
+        }
+    }
     else
     {
         LOG(TINY_LOG_WRN, "[%p] Unknown hdlc U-frame received\n", handle);

src/proto/fd/tiny_fd_proto_logger.c

@@ -116,13 +116,15 @@ static const char *__get_frame_subtype_str(uint8_t control)
         switch (control & HDLC_S_FRAME_TYPE_MASK)
         {
             case HDLC_S_FRAME_TYPE_RR:  return "  RR";
+            case HDLC_S_FRAME_TYPE_RNR: return " RNR";
             case HDLC_S_FRAME_TYPE_REJ: return " REJ";
             default:                    return " UNK";
         }
     }
     switch (control & HDLC_U_FRAME_TYPE_MASK)
     {
         case HDLC_U_FRAME_TYPE_UA:   return "  UA";
+        case HDLC_U_FRAME_TYPE_DM:   return "  DM";
         case HDLC_U_FRAME_TYPE_FRMR: return "FRMR";
         case HDLC_U_FRAME_TYPE_RSET: return "RSET";
         case HDLC_U_FRAME_TYPE_SABM: return "SABM";

unittest/tiny_fd_abm_tests.cpp

@@ -238,17 +238,17 @@ TEST(TINY_FD_ABM, ABM_RecieveOutOfOrderIFrames)
     CHECK_EQUAL(0x7E, outBuffer[7]); // Flag
 }
 
-TEST(TINY_FD_ABM, ABM_SendSABMOnIFrameIfDisconnected)
+TEST(TINY_FD_ABM, ABM_SendDMOnIFrameIfDisconnected)
 {
-    // If we are disconnected, we should send SABM frame on I-frame
+    // Per HDLC ABM spec, if we are disconnected and receive I-frame, send DM (Disconnect Mode)
     auto read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x03\x00\x11\x7E", 5); // I-frame in order
     CHECK_EQUAL(TINY_SUCCESS, read_result);
     auto len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
     CHECK_EQUAL(4, len);
-    // Check SABM frame
+    // DM control = (0x0C | 0x03) | P_BIT = 0x0F | 0x10 = 0x1F
     CHECK_EQUAL(0x7E, outBuffer[0]); // Flag
-    CHECK_EQUAL(0x03, outBuffer[1]); // Address field - CR bit must be cleared
-    CHECK_EQUAL(0x3F, outBuffer[2]); // SABM packet
+    CHECK_EQUAL(0x01, outBuffer[1]); // Address field - CR bit cleared (response)
+    CHECK_EQUAL(0x1F, outBuffer[2]); // DM packet with P/F bit
     CHECK_EQUAL(0x7E, outBuffer[3]); // Flag
 }
 
@@ -419,4 +419,97 @@ TEST(TINY_FD_ABM, ABM_CheckReceiveReadyWithCommandBitCleared)
     CHECK_EQUAL(TINY_SUCCESS, read_result);
     int len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
     CHECK_EQUAL(0, len); // We should have sent RR frame
+}
+
+TEST(TINY_FD_ABM, ABM_SendDMOnSFrameIfDisconnected)
+{
+    // Per HDLC ABM spec, if we are disconnected and receive S-frame, send DM
+    // RR frame with N(R)=0: control = 0x01
+    auto read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x03\x01\x7E", 4); // RR S-frame
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    auto len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
+    CHECK_EQUAL(4, len);
+    // DM control = (0x0C | 0x03) | P_BIT = 0x0F | 0x10 = 0x1F
+    CHECK_EQUAL(0x7E, outBuffer[0]); // Flag
+    CHECK_EQUAL(0x01, outBuffer[1]); // Address field - CR bit cleared (response)
+    CHECK_EQUAL(0x1F, outBuffer[2]); // DM packet with P/F bit
+    CHECK_EQUAL(0x7E, outBuffer[3]); // Flag
+}
+
+TEST(TINY_FD_ABM, ABM_FRMRReceiveTriggersReconnect)
+{
+    // FRMR should trigger disconnection and SABM reconnection attempt
+    establishConnection();
+    CHECK(connected);
+    // Send FRMR frame: control = HDLC_U_FRAME_TYPE_FRMR | HDLC_U_FRAME_BITS = 0x84 | 0x03 = 0x87
+    auto read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x01\x87\x00\x00\x7E", 6); // FRMR with 2 info bytes
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    CHECK(!connected); // Should have disconnected
+    // Should get SABM reconnection attempt
+    auto len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
+    CHECK_EQUAL(4, len);
+    CHECK_EQUAL(0x7E, outBuffer[0]); // Flag
+    CHECK_EQUAL(0x03, outBuffer[1]); // Address field - CR bit set (command)
+    CHECK_EQUAL(0x3F, outBuffer[2]); // SABM packet (0x2C | 0x13 with P bit = 0x2F | 0x10 = 0x3F)
+    CHECK_EQUAL(0x7E, outBuffer[3]); // Flag
+}
+
+TEST(TINY_FD_ABM, ABM_RSETResetsSequenceNumbers)
+{
+    establishConnection();
+    // Send some I-frames to advance sequence numbers
+    auto read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x03\x00\x11\x7E", 5); // I-frame N(S)=0
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    // Drain RR response
+    int len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
+    CHECK(len > 0);
+    // Now send RSET: control = HDLC_U_FRAME_TYPE_RSET | HDLC_U_FRAME_BITS = 0x8C | 0x03 = 0x8F
+    read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x03\x8F\x7E", 4); // RSET frame
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    // Should respond with UA
+    len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
+    CHECK_EQUAL(4, len);
+    CHECK_EQUAL(0x7E, outBuffer[0]); // Flag
+    CHECK_EQUAL(0x01, outBuffer[1]); // Address field - CR bit cleared (response)
+    CHECK_EQUAL(0x73, outBuffer[2]); // UA packet
+    CHECK_EQUAL(0x7E, outBuffer[3]); // Flag
+    // After RSET, send I-frame N(S)=0 again — should succeed since V(R) was reset to 0
+    read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x03\x00\x22\x7E", 5); // I-frame N(S)=0
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
+    CHECK(len > 0);
+    // Should get RR with N(R)=1 confirming the frame was accepted
+    CHECK_EQUAL(0x7E, outBuffer[0]); // Flag
+    CHECK_EQUAL(0x01, outBuffer[1]); // Address field
+    CHECK_EQUAL(0x31, outBuffer[2]); // RR with N(R)=1
+    CHECK_EQUAL(0x7E, outBuffer[3]); // Flag
+}
+
+TEST(TINY_FD_ABM, ABM_RNRPausesTransmission)
+{
+    establishConnection();
+    // Send I-frame first to advance sequence
+    auto read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x03\x00\x11\x7E", 5); // I-frame
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    // Drain RR
+    int len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
+    CHECK(len > 0);
+    // Send RNR S-frame: control = HDLC_S_FRAME_BITS | HDLC_S_FRAME_TYPE_RNR | (N(R)<<5)
+    // = 0x01 | 0x04 | (1<<5) = 0x25
+    read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x03\x25\x7E", 4); // RNR with N(R)=1
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    // RNR should be accepted without error (confirms N(R)=1)
+    // No response frame should be generated (RNR doesn't have CR bit set as command here)
+    len = tiny_fd_get_tx_data(handle, outBuffer.data(), outBuffer.size(), 100);
+    CHECK_EQUAL(0, len);
+}
+
+TEST(TINY_FD_ABM, ABM_DMReceiveDisconnects)
+{
+    establishConnection();
+    CHECK(connected);
+    // Receive DM from peer: control = HDLC_U_FRAME_TYPE_DM | HDLC_U_FRAME_BITS = 0x0C | 0x03 = 0x0F
+    auto read_result = tiny_fd_on_rx_data(handle, (uint8_t *)"\x7E\x01\x0F\x7E", 4); // DM frame
+    CHECK_EQUAL(TINY_SUCCESS, read_result);
+    CHECK(!connected); // Should have disconnected
 }