Enum DMSCFrameType 

pub enum DMSCFrameType {
    Control = 1,
    Data = 2,
    Auth = 3,
    KeepAlive = 4,
    Error = 5,
    Encrypted = 6,
}

Protocol frame type enumeration defining the categories of protocol frames.

This enumeration classifies all protocol frames used in the DMSC protocol for network communication. Each frame type serves a specific purpose in the communication lifecycle, from initial connection establishment through data transmission, authentication, and connection maintenance. Frame type identification enables proper routing and processing of incoming frames by protocol handlers.

Frame Type Hierarchy

• Control Frames (0x01): Protocol management and state transitions
• Data Frames (0x02): Application data payload transmission
• Auth Frames (0x03): Authentication and authorization exchanges
• Keep-Alive Frames (0x04): Connection liveness verification
• Error Frames (0x05): Error reporting and status communication
• Encrypted Frames (0x06): Pre-encrypted payload transmission

Frame Processing Guidelines

Protocol implementations should process frames in the following order:

1. First validate the frame header magic number and version
2. Extract and validate the frame type from the header
3. Route the frame to the appropriate handler based on frame type
4. Process the frame payload according to type-specific rules
5. Send appropriate response frames if required

Python Bindings

When compiled with the pyo3 feature, this enum provides Python bindings for frame type identification:

from dmsc import DMSCFrameType

# Identify frame types for protocol handling
control_type = DMSCFrameType.Control()
data_type = DMSCFrameType.Data()
auth_type = DMSCFrameType.Auth()

# Convert between types and byte values
frame_type_value = DMSCFrameType.from_u8(0x01)
byte_value = data_type.to_u8()  # Returns 0x02

Thread Safety

This enum is fully thread-safe and can be shared across concurrent contexts without additional synchronization. The Copy trait enables efficient passing of frame type values through function arguments and return types.

Storage and Transmission

Frame type values are stored as single bytes making them efficient for network transmission and compact storage. The Hash trait enables frame type usage as dictionary keys in collection types and provides efficient lookup performance.

Examples

Basic frame type creation and conversion:

use dmsc::protocol::frames::DMSCFrameType;

let control = DMSCFrameType::Control;
let data = DMSCFrameType::Data;

assert_eq!(control as u8, 0x01);
assert_eq!(data as u8, 0x02);
assert_ne!(control, data);

Frame type matching in protocol handling:

use dmsc::protocol::frames::DMSCFrameType;

fn handle_frame_type(frame_type: DMSCFrameType) -> &str {
    match frame_type {
        DMSCFrameType::Control => "Control frame - managing protocol state",
        DMSCFrameType::Data => "Data frame - processing payload",
        DMSCFrameType::Auth => "Auth frame - handling authentication",
        DMSCFrameType::KeepAlive => "Keep-alive frame - verifying connection",
        DMSCFrameType::Error => "Error frame - reporting error condition",
        DMSCFrameType::Encrypted => "Encrypted frame - processing secure payload",
    }
}

assert_eq!(handle_frame_type(DMSCFrameType::Data), "Data frame - processing payload");

Converting between byte values and frame types:

use dmsc::protocol::frames::DMSCFrameType;

// Convert byte to frame type
let frame_type = DMSCFrameType::from_u8(0x03);
assert_eq!(frame_type, Some(DMSCFrameType::Auth));

// Invalid byte value returns None
let invalid = DMSCFrameType::from_u8(0xFF);
assert_eq!(invalid, None);

Variants

Control = 1

Control frame for protocol management operations.

Control frames manage the protocol state machine and handle connection lifecycle events. They are used for operations such as connection initialization, version negotiation, feature flags exchange, and graceful connection termination. Control frames must be processed before any data frames to ensure proper protocol state establishment.

Control Frame Payload Structure

Control frame payloads contain a command identifier followed by command-specific parameters encoded in a type-length-value (TLV) format.

Common Control Commands

• Connection Request (0x01): Initiate new connection
• Connection Ack (0x02): Confirm connection establishment
• Disconnect Request (0x03): Initiate graceful disconnection
• Ping (0x04): Request keep-alive response
• Pong (0x05): Keep-alive response
• Protocol Negotiation (0x10): Negotiate protocol features

Data = 2

Data frame for application payload transmission.

Data frames carry the primary application data through the protocol. They are the most frequently used frame type in normal protocol operation and support both streaming and message-based data transfer modes. Data frames are sequenced and delivered in-order to ensure data integrity.

Data Frame Characteristics

• Sequencing: Each data frame has a unique sequence number
• Ordering: Frames are delivered in sequence number order
• Flow Control: Sliding window prevents buffer overflow
• Aggregation: Multiple small payloads can be aggregated

Payload Considerations

• Maximum payload size is defined by protocol configuration
• Large payloads may be fragmented across multiple frames
• Payload compression is available as an optional feature

Auth = 3

Authentication frame for credential exchange and verification.

Authentication frames facilitate the authentication process between communicating parties. They carry authentication tokens, certificates, challenge-response pairs, and authentication results. All auth frames are encrypted using the current session encryption keys.

Authentication Flow

1. Client sends authentication request with credentials
2. Server validates credentials and returns challenge
3. Client responds to challenge with proof of possession
4. Server confirms successful authentication

Supported Authentication Methods

• JWT token authentication
• Certificate-based mutual TLS
• Pre-shared key authentication
• OAuth 2.0 token exchange

KeepAlive = 4

Keep-alive frame for connection liveness verification.

Keep-alive frames maintain connection vitality and detect unresponsive peers. They are exchanged periodically between connected parties to prevent connection timeout and detect connection failures. Keep-alive frames have minimal overhead and contain no payload.

Error = 5

Error frame for error condition reporting.

Error frames communicate error conditions from one protocol party to another. They include an error code and human-readable error message to facilitate debugging and error recovery. Error frames may be sent in response to any invalid protocol message.

Encrypted = 6

Encrypted frame for pre-encrypted payload transmission.

Encrypted frames carry payloads that have been encrypted by the application layer before being passed to the protocol. This allows applications to use custom encryption schemes or to encrypt data end-to-end between application endpoints. The protocol encrypts the encrypted payload as normal data.

Use Cases

• End-to-end encrypted application data
• Custom encryption algorithm requirements
• Regulatory compliance requiring specific encryption
• Integration with external encryption systems

Security Considerations

When using encrypted frames, the outer protocol encryption provides transport security while the inner encrypted payload provides end-to-end security between application endpoints.

Implementations

impl DMSCFrameType

pub fn from_u8(value: u8) -> Option<Self>

Convert from byte to frame type

Trait Implementations

impl Clone for DMSCFrameType

fn clone(&self) -> DMSCFrameType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DMSCFrameType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'py> IntoPyObject<'py> for DMSCFrameType

type Target = DMSCFrameType

The Python output type

type Output = Bound<'py, <DMSCFrameType as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for DMSCFrameType

fn eq(&self, other: &DMSCFrameType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for DMSCFrameType

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for DMSCFrameType

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = c"Protocol frame type enumeration defining the categories of protocol frames.\n\nThis enumeration classifies all protocol frames used in the DMSC protocol\nfor network communication. Each frame type serves a specific purpose in\nthe communication lifecycle, from initial connection establishment through\ndata transmission, authentication, and connection maintenance. Frame type\nidentification enables proper routing and processing of incoming frames\nby protocol handlers.\n\n## Frame Type Hierarchy\n\n- **Control Frames (0x01)**: Protocol management and state transitions\n- **Data Frames (0x02)**: Application data payload transmission\n- **Auth Frames (0x03)**: Authentication and authorization exchanges\n- **Keep-Alive Frames (0x04)**: Connection liveness verification\n- **Error Frames (0x05)**: Error reporting and status communication\n- **Encrypted Frames (0x06)**: Pre-encrypted payload transmission\n\n## Frame Processing Guidelines\n\nProtocol implementations should process frames in the following order:\n1. First validate the frame header magic number and version\n2. Extract and validate the frame type from the header\n3. Route the frame to the appropriate handler based on frame type\n4. Process the frame payload according to type-specific rules\n5. Send appropriate response frames if required\n\n## Python Bindings\n\nWhen compiled with the `pyo3` feature, this enum provides Python bindings\nfor frame type identification:\n```python\nfrom dmsc import DMSCFrameType\n\n# Identify frame types for protocol handling\ncontrol_type = DMSCFrameType.Control()\ndata_type = DMSCFrameType.Data()\nauth_type = DMSCFrameType.Auth()\n\n# Convert between types and byte values\nframe_type_value = DMSCFrameType.from_u8(0x01)\nbyte_value = data_type.to_u8() # Returns 0x02\n```\n\n## Thread Safety\n\nThis enum is fully thread-safe and can be shared across concurrent contexts\nwithout additional synchronization. The Copy trait enables efficient passing\nof frame type values through function arguments and return types.\n\n## Storage and Transmission\n\nFrame type values are stored as single bytes making them efficient for network\ntransmission and compact storage. The Hash trait enables frame type usage as\ndictionary keys in collection types and provides efficient lookup performance.\n\n# Examples\n\nBasic frame type creation and conversion:\n```rust,ignore\nuse dmsc::protocol::frames::DMSCFrameType;\n\nlet control = DMSCFrameType::Control;\nlet data = DMSCFrameType::Data;\n\nassert_eq!(control as u8, 0x01);\nassert_eq!(data as u8, 0x02);\nassert_ne!(control, data);\n```\n\nFrame type matching in protocol handling:\n```rust,ignore\nuse dmsc::protocol::frames::DMSCFrameType;\n\nfn handle_frame_type(frame_type: DMSCFrameType) -> &str {\n match frame_type {\n DMSCFrameType::Control => \"Control frame - managing protocol state\",\n DMSCFrameType::Data => \"Data frame - processing payload\",\n DMSCFrameType::Auth => \"Auth frame - handling authentication\",\n DMSCFrameType::KeepAlive => \"Keep-alive frame - verifying connection\",\n DMSCFrameType::Error => \"Error frame - reporting error condition\",\n DMSCFrameType::Encrypted => \"Encrypted frame - processing secure payload\",\n }\n}\n\nassert_eq!(handle_frame_type(DMSCFrameType::Data), \"Data frame - processing payload\");\n```\n\nConverting between byte values and frame types:\n```rust,ignore\nuse dmsc::protocol::frames::DMSCFrameType;\n\n// Convert byte to frame type\nlet frame_type = DMSCFrameType::from_u8(0x03);\nassert_eq!(frame_type, Some(DMSCFrameType::Auth));\n\n// Invalid byte value returns None\nlet invalid = DMSCFrameType::from_u8(0xFF);\nassert_eq!(invalid, None);\n```\x00"

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<DMSCFrameType>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyTypeInfo for DMSCFrameType

const NAME: &'static str = "DMSCFrameType"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl Copy for DMSCFrameType

impl Eq for DMSCFrameType

impl ExtractPyClassWithClone for DMSCFrameType

impl StructuralPartialEq for DMSCFrameType