Struct CanFrame 

pub struct CanFrame {
    pub id: u32,
    pub extended: bool,
    pub rtr: bool,
    pub error: bool,
    pub fd: bool,
    pub brs: bool,
    pub esi: bool,
    pub data: Vec<u8>,
    pub rtr_dlc: u8,
}

One CAN frame, classic or FD, in or out.

data is the payload as bytes; how it is written in JSON is the encoding field’s job (CanFrame::from_action), never a guess.

Fields

id: u32

11-bit or 29-bit identifier, without any of the SocketCAN flag bits.

extended: bool

True for a 29-bit identifier. Explicit, never inferred from magnitude: 0x123 is a perfectly legal extended identifier and is a different frame from standard 0x123.

rtr: bool

Remote transmission request: a request for data, carrying none. Not valid on FD.

error: bool

This is an error frame. The identifier is then a bitmask of error classes, not an address.

fd: bool

CAN FD rather than classic CAN 2.0.

brs: bool

Bit-rate switch: the data phase used the faster bit rate. FD only.

esi: bool

Error state indicator: the transmitter was error-passive. FD only, receive-side only.

data: Vec<u8>

Payload. Empty for an RTR frame, whose length lives in rtr_dlc.

rtr_dlc: u8

The number of bytes an RTR frame is requesting. Meaningless on any other frame.

Implementations

impl CanFrame

pub fn classic(id: u32, extended: bool, data: Vec<u8>) -> Result<Self>

A classic data frame.

pub fn fd(id: u32, extended: bool, data: Vec<u8>, brs: bool) -> Result<Self>

A CAN FD data frame.

pub fn remote(id: u32, extended: bool, dlc: u8) -> Result<Self>

A remote transmission request for dlc bytes.

pub fn validate(&self) -> Result<()>

Everything that must hold before a frame can be encoded.

Called by every constructor and again by Self::to_wire_bytes, so a frame built by hand cannot skip it.

pub fn dlc(&self) -> u8

The data length code this frame will carry on the wire.

pub fn id_word(&self) -> u32

The composite SocketCAN identifier word: the identifier plus the EFF/RTR/ERR flag bits.

pub fn from_id_word( id_word: u32, data: Vec<u8>, fd: bool, brs: bool, esi: bool, ) -> Self

Rebuild a frame from a composite identifier word and a payload.

This is the receive-side entry point for both transports: the Linux one gets the word from socketcan’s Frame::id_word(), and the UDP one from the first four octets of the datagram. Keeping the flag decoding here — rather than once per transport — is what lets tests/server/can/frame_test.rs prove it on a machine with no CAN stack.

pub fn to_wire_bytes(&self) -> Result<Vec<u8>>

Encode as struct can_frame (16 octets) or struct canfd_frame (72 octets).

Little-endian, matching <linux/can.h> on every architecture Linux supports CAN on. The two layouts differ in more than length, so the tests pin both:

struct can_frame {          struct canfd_frame {
  canid_t can_id;   // 4      canid_t can_id;   // 4
  __u8    len;      // 1      __u8    len;      // 1
  __u8    __pad;    // 1      __u8    flags;    // 1   <- BRS/ESI/FDF live here
  __u8    __res0;   // 1      __u8    __res0;   // 1
  __u8    len8_dlc; // 1      __u8    __res1;   // 1
  __u8    data[8];  // 8      __u8    data[64]; // 64
};                          };

Note len is a byte count in both structs — the kernel does the DLC encoding itself on the way to the controller. The DLC still matters and is still reported to the model, because it is what appears on the physical bus and what a DBC file is written against; for a remote frame it is the only content there is, so it is written into len, which is where the kernel reads an RTR request length from.

pub fn from_wire_bytes(bytes: &[u8]) -> Result<Self>

Decode a struct can_frame or struct canfd_frame.

The length picks the layout, which is exactly how read() on an AF_CAN socket distinguishes them: an FD-enabled socket returns 72 octets for an FD frame and 16 for a classic one.

pub fn error_classes(&self) -> Option<Vec<&'static str>>

The error classes this frame reports, as names, or None if it is not an error frame.

The model is given names rather than the bitmask because a mask is exactly the kind of thing it cannot reliably decode, and because these names are what candump prints and what every CAN document calls them.

pub fn bus_state(&self) -> Option<BusState>

The controller state this error frame reports, if it reports one.

None for a data frame, and for an error frame that says nothing about confinement — a lost arbitration is not a state change. This is the emit condition for can_bus_state_changed, so getting it wrong would either flood the model with non-transitions or hide a bus-off.

pub fn id_hex(&self) -> String

The identifier written the way automotive documentation writes it.

pub fn describe(&self) -> String

A one-line description for the log.

pub fn to_event_data(&self) -> Map<String, Value>

Event data for can_frame_received and friends.

data is hex and data_encoding says so, every time. See Self::from_action for why hex is the default here and not in most of this codebase.

pub fn from_action(action: &Value) -> Result<Self>

Build a frame from a send_can_frame action object.

Pure, so the whole action vocabulary is tested on a machine with no CAN stack.

encoding is read, never sniffed

"hex" is the default, which is unusual in this codebase and is right here: a CAN payload is eight bytes whose meaning is defined by a DBC file NetGet does not have. There is no text to default to. "text" is offered because an ASCII payload does occur (diagnostic VIN responses, some telematics gateways) and writing "484921" for "HI!" helps nobody.

The executor really decodes what the field says. It never guesses: "48656c6c6f" is simultaneously valid text and valid hex, and only the sender knows which it meant. This is the send_tcp_data defect the root CLAUDE.md records, where the documentation promised hex and the executor called as_bytes(), putting literal ASCII on the wire.

Trait Implementations

impl Clone for CanFrame

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CanFrame

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

Formats the value using the given formatter.

impl Eq for CanFrame

impl PartialEq for CanFrame

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CanFrame