SCHC Rule Format for Reliability Fragmentation in Constrained Networks

Introduction RFC8724 specifies the SCHC framework for compressing and fragmenting IPv6/UDP packets for LPWANs. While its fragmentation mechanism efficiently segments large messages, small messages that do not meet the fragmentation threshold remain vulnerable to loss due to the absence of recovery procedures. This document introduces a new Rule Format for Reliability Fragmentation that adapts SCHC Fragmentation for small-message reliability. It does so by adding a size field to every fragment and by modifying the state machine to maintain a persistent session with cyclic windowing, thereby enabling recovery even when individual fragments are lost.

Reliability Fragmentation Overview The fundamental enhancement in Reliability Fragmentation is the extension of SCHC Fragmentation to small messages. This is achieved by: Adding a Size Field: Each fragment carries an additional field indicating the total size (in bytes) of the SCHC-compressed message. This allows the receiver to understand the complete expected payload even when messages are not naturally segmented. Persistent Session with Wrap-Around Windows: Unlike conventional fragmentation where the session terminates upon complete message reassembly, the Reliability Fragmentation session remains open indefinitely. The window indices wrap around, enabling recovery only within the bounds of the maintained window memory. Dual Operational Modes: Two distinctly different modes are defined to address diverse network conditions: RelNoAck: Optimized for environments where low latency is prioritized and occasional losses are acceptable. RelAckOnErr: Designed for scenarios requiring strict reliability by actively recovering lost fragments.

Detailed Description of Reliability Modes

RelNoAck Mode RelNoAck mode is derived from the SCHC No-Ack fragmentation mechanism. Its main characteristics are: Continuous Transmission: Fragments are sent continuously without waiting for acknowledgments for each fragment. Size Field Utilization: The inclusion of a size field enables the receiver to immediately ascertain the complete message length, even if fragments arrive out of sequence. Loss Tolerance: In the absence of acknowledgment-driven recovery, a configurable threshold of tolerated loss is defined. If fragment loss remains within this threshold, the upper layers may accept a partial reassembly. Simplified State Machine: The state machine does not trigger explicit recovery procedures upon detecting a missing fragment. Instead, fragments are forwarded as they arrive, and any gaps are either ignored or handled by upper-layer protocols if the loss is deemed acceptable. This mode is ideal for networks where retransmission overhead is undesirable and where some loss does not critically affect application performance.

RelAckOnErr Mode RelAckOnErr mode builds on the SCHC Ack-On-Error fragmentation mechanism. Its operation involves: Error Detection: The receiver monitors the sequence of fragments using the embedded RuleID and fragmentation parameters. Explicit Recovery Trigger: If a fragment is identified as missing within the active window, the receiver generates a negative acknowledgment or error report to the sender. Retransmission Mechanism: Upon receiving the error notification, the sender retransmits the missing fragment(s) to ensure complete message reconstruction. Enhanced Reliability: This mode provides robust recovery, ensuring that even if one or more fragments are lost, the complete message is eventually delivered without error. Dynamic Window Management: The state machine continuously manages the cyclic window, tracking received and missing fragments, and initiating recovery procedures only within the window's scope. RelAckOnErr is best suited for applications where data integrity is critical and where the overhead of retransmissions is justified by the need for complete and error-free delivery.

Packet Format for Reliability Fragmentation The packet format for Reliability Fragmentation extends the SCHC Fragmentation format specified in RFC8724 with an additional size field. The structure is as follows:

Reliability RuleID: Identifies that the packet adheres to the Reliability Fragmentation format. Flags & Mode: Indicate the operational mode (RelNoAck or RelAckOnErr) and other control parameters. Size Field: An N-bit field, defined in the SCHC Context, representing the total byte-length of the compressed message. Data Segment: The payload portion produced by SCHC Compression or Aggregation.

State Machine Modifications The state machine for Reliability Fragmentation is adapted from the SCHC Fragmentation state machine in RFC8724 with the following key modifications: Persistent Session:
The session remains open after the complete transmission of a message, allowing the state machine to support continuous monitoring and recovery within a cyclic window. Window Wrap-Around:
Sequence numbers or window indices wrap around. Recovery procedures are constrained to the current window maintained in memory, ensuring resource constraints are respected. Mode-Specific Behavior: In RelNoAck mode, the state machine does not wait for acknowledgments; fragments are processed immediately, and gaps are tolerated within a configured loss threshold. In RelAckOnErr mode, the state machine actively monitors for missing fragments. Upon detecting a gap, it triggers a recovery procedure that requests retransmission of the missing fragment(s).

Operational Considerations The design of Reliability Fragmentation is intended to seamlessly integrate with existing SCHC operations while providing enhanced reliability for small messages. Key considerations include: Immediate Upper-Layer Delivery:
In both modes, received fragments are promptly forwarded to the upper layers. The size field assists in determining when the full message has been received. Policy Flexibility:
Network operators can select between the SEND_OUT_OF_ORDER behavior (suitable for RelNoAck) and SEND_IN_ORDER behavior (necessary for RelAckOnErr) based on application latency and recovery requirements. Dynamic MTU Adaptation:
Changes in the L2 Maximum Transmission Unit require dynamic adjustment of the window size. The system ensures that all fragments adhere to the current MTU, preserving data integrity.

Flow Diagram The diagram below illustrates the flow of data through the Reliability Fragmentation process:

| SCHC Compression Module | ----> | Reliability Fragmentation | | Packet | | (Compressed Data) | | (Fragmentation & Recovery) | +-------------------+ +-----------------------------+ +---------------+----------------+ | v +--------------------------------+ | Lower Layers (L2 Transmission) | | of Reliability Fragments | +--------------------------------+ ]]>

Security Considerations The modifications introduced by Reliability Fragmentation, such as the persistent session and additional size field, do not fundamentally alter the SCHC security model defined in RFC8724. Implementations must ensure that integrity and authenticity checks cover all fragments and that recovery procedures do not create new vulnerabilities.

IANA Considerations This document requests that IANA assign new code points for the Reliability Fragmentation modes (RelNoAck and RelAckOnErr) and update the SCHC Rule Format registry to include the additional size field definition.

Examples and Use Cases

Example 1: RelNoAck for Sensor Networks In a sensor network where data is periodically transmitted, the RelNoAck mode is employed. Sensors compress their data using SCHC Compression, and the resulting packets are processed by the Reliability Fragmentation module. Fragments are sent continuously without waiting for acknowledgments, and the size field enables the receiver to piece together the complete message. Occasional losses are tolerated within a predefined threshold, making this mode suitable for non-critical monitoring applications.

Example 2: RelAckOnErr for Critical Data Delivery In applications where data integrity is paramount, such as in industrial monitoring, the RelAckOnErr mode is utilized. Here, the receiver monitors the sequence of fragments and, upon detecting any missing fragment within the active window, sends a negative acknowledgment to trigger retransmission. This ensures that even in the presence of losses, the complete message is eventually reassembled without error.