Ethernet frames partial handling (#1)

lorenzoditucci · web-flow · commit a13703042b2f · 2025-05-28T16:25:06.000+02:00
diff --git a/can/ethernetframe.py b/can/ethernetframe.py
@@ -0,0 +1,67 @@
+from enum import Enum
+from typing import Optional
+from . import typechecking
+
+class DirectionFlag(Enum):
+    """The state in which ethernetFrame dir can be"""
+
+    Rx = 0
+    Tx = 1
+    TxRq = 2
+
+class EthernetFrame:
+
+    def __init__( 
+        self,
+        timestamp: float = 0.0,
+        source_address: Optional[bytearray] = None,
+        channel: Optional[typechecking.Channel] = None,
+        destination_address: Optional[bytearray] = None,
+        direction: Optional[DirectionFlag] = None,
+        
+        # EtherType indicates the protocol for ethernet payload data 
+        ether_type: Optional[bytearray] = None,
+
+        # TPID when VLAN tag valid, zero when no
+        # VLAN. See Ethernet standard specification.
+        tpid: Optional[int] = None,
+
+        # TCI when VLAND tag valid, zero when no
+        # VLAN. See Ethernet standard specification.
+        tci: Optional[int] = None,
+        payloadLength: int = 0,
+        data: Optional[typechecking.CanData] = None,
+    ): 
+        self.timestamp = timestamp
+        self.source_address = source_address
+        self.channel = channel
+        self.destination_address = destination_address
+        self.direction = direction
+        self.type = ether_type
+        self.tpid = tpid
+        self.tci = tci
+        self.payloadLength = payloadLength
+
+        if data is None:
+            self.data = bytearray()
+        elif isinstance(data, bytearray):
+            self.data = data
+        else:
+            try:
+                self.data = bytearray(data)
+            except TypeError as error:
+                err = f"Couldn't create message from {data} ({type(data)})"
+                raise TypeError(err) from error
+            
+    def __str__(self) -> str:
+        field_strings = [f"EthernetFrame - Timestamp: {self.timestamp:>15.6f}"]
+        field_strings.append(f"Source Address: {self.source_address}")
+        field_strings.append(f"Destination Address: {self.destination_address}")
+        field_strings.append(f"Direction: {self.direction}")
+        field_strings.append(f"EtherType: {self.type}")
+        field_strings.append(f"TPID: {self.tpid}")
+        field_strings.append(f"TCI: {self.tci}")
+        field_strings.append(f"Payload Length: {self.payloadLength}")
+        field_strings.append(f"Data: {self.data}")
+       
+        return "\n".join(field_strings)
diff --git a/can/ethernetframeext.py b/can/ethernetframeext.py
@@ -0,0 +1,107 @@
+from typing import Optional
+
+from .ethernetframe import DirectionFlag
+from . import typechecking
+
+class EthernetFrameExt:  # pylint: disable=too-many-instance-attributes; OK for a dataclass
+
+    def __init__(  # pylint: disable=too-many-locals, too-many-arguments
+        self,
+        timestamp: float = 0.0,
+        struct_length: int = 0,
+        flags: int = 0,
+        channel: Optional[typechecking.Channel] = None,
+        hardware_channel: Optional[int] = None,
+        duration: Optional[int] = None,
+        checksum: Optional[int] = None,
+        direction: Optional[DirectionFlag] = None,
+        # Number of valid frameData bytes
+        length: int = 0,
+        # Handle which refer the corresponding EthernetFrameForwarded event
+        handle: int = 0,
+        # Frame data
+        data: Optional[typechecking.CanData] = None
+    ):
+        self.timestamp = timestamp
+        self.struct_length = struct_length
+        self.flags = flags
+        self.channel = channel
+        self.hardware_channel = hardware_channel
+        self.duration = duration
+        self.checksum = checksum
+        self.direction= direction
+        self.length = length
+        self.handle = handle
+
+        if data is None:
+            self.data = bytearray()
+        elif isinstance(data, bytearray):
+            self.data = data
+        else:
+            try:
+                self.data = bytearray(data)
+            except TypeError as error:
+                err = f"Couldn't create message from {data} ({type(data)})"
+                raise TypeError(err) from error
+
+    def __str__(self) -> str:
+        field_strings = [f"ETHFEXT - Timestamp: {self.timestamp:>15.6f}"]
+        flag_string = f"flags: {self.flags}"
+        field_strings.append(flag_string)
+
+
+        data_strings = "Data: "
+        if self.data is not None:
+            data_strings += self.data[: len(self.data)].hex(" ")
+        if data_strings:  # if not empty
+            field_strings.append(data_strings.ljust(24, " "))
+        else:
+            field_strings.append(" " * 24)
+
+        if (self.data is not None) and (self.data.isalnum()):
+            field_strings.append(f"'{self.data.decode('utf-8', 'replace')}'")
+
+        if self.channel is not None:
+            try:
+                field_strings.append(f"Channel: {self.channel}")
+            except UnicodeEncodeError:
+                pass
+        if self.hardware_channel is not None:
+            try:
+                field_strings.append(f"Hardware Channel: {self.hardware_channel}")
+            except UnicodeEncodeError:
+                pass
+        if self.direction is not None:
+            try:
+                field_strings.append(f"Direction: {self.direction}")
+            except UnicodeEncodeError:
+                pass
+        if self.length is not None:
+            try:
+                field_strings.append(f"Length: {self.length}")
+            except UnicodeEncodeError:
+                pass
+        if self.handle is not None:
+            try:
+                field_strings.append(f"Handle: {self.handle}")
+            except UnicodeEncodeError:
+                pass
+        if self.checksum is not None:
+            try:
+                field_strings.append(f"Checksum: {self.checksum}")
+            except UnicodeEncodeError:
+                pass
+        if self.duration is not None:
+            try:
+                field_strings.append(f"Duration: {self.duration}")
+            except UnicodeEncodeError:
+                pass
+        if self.struct_length is not None:
+            try:
+                field_strings.append(f"Struct Length: {self.struct_length}")
+            except UnicodeEncodeError:
+                pass
+        
+
+
+        return "\n".join(field_strings).strip()
diff --git a/can/io/blf.py b/can/io/blf.py
@@ -20,6 +20,9 @@
 from typing import Any, BinaryIO, Generator, List, Optional, Tuple, Union, cast
 
 from ..message import Message
+from ..ethernetframe import EthernetFrame
+from ..unknownmessage import UnknownMessage
+from ..ethernetframeext import EthernetFrameExt
 from ..typechecking import StringPathLike
 from ..util import channel2int, dlc2len, len2dlc
 from .generic import BinaryIOMessageReader, FileIOMessageWriter
@@ -76,14 +79,27 @@ class BLFParseError(Exception):
 # group name length, marker name length, description length
 GLOBAL_MARKER_STRUCT = struct.Struct("<LLL3xBLLL12x")
 
+# sourceAddress, channel, destinationAddress, dir, type, tpid, tci, payloadLength, reservedEthernetFrame
+ETHERNET_FRAME_STRUCT = struct.Struct("<6sH6sHHHHHQ")
+# after this, max 1500 data bytes of payload follows (ethernet header not included)
+
+# structLength, flags, channel, hardwareChannel, frameduration, framechecksum, dir, frameLength, framehandle, reservedEthernetFrameEx
+ETHERNET_FRAME_EX_STRUCT = struct.Struct("<HHHHQLHHLL")
+# after this follows up to 1612 bytes of frameData containing: Ethernet header + Ethernet payload
 
 CAN_MESSAGE = 1
 LOG_CONTAINER = 10
+ETHERNET_FRAME = 71
 CAN_ERROR_EXT = 73
 CAN_MESSAGE2 = 86
 GLOBAL_MARKER = 96
 CAN_FD_MESSAGE = 100
 CAN_FD_MESSAGE_64 = 101
+ETHERNET_FRAME_EX = 120 # < Ethernet packet extended object
+# Related ethernet containers not yet supported:
+# ETHERNET_FRAME_FORWARDED = 121 # < Ethernet packet forwarded object 
+# ETHERNET_ERROR_EX = 122 # < Ethernet error extended object 
+# ETHERNET_ERROR_FORWARDED = 123 # < Ethernet error forwarded object 
 
 NO_COMPRESSION = 0
 ZLIB_DEFLATE = 2
@@ -100,7 +116,7 @@ class BLFParseError(Exception):
 
 
 def timestamp_to_systemtime(timestamp: float) -> TSystemTime:
-    if timestamp is None or timestamp < 631152000:
+    if timestamp is None:
         # Probably not a Unix timestamp
         return 0, 0, 0, 0, 0, 0, 0, 0
     t = datetime.datetime.fromtimestamp(round(timestamp, 3))
@@ -167,7 +183,7 @@ def __init__(
         self._tail = b""
         self._pos = 0
 
-    def __iter__(self) -> Generator[Message, None, None]:
+    def __iter__(self) -> Generator[Union[Message, UnknownMessage, EthernetFrame, EthernetFrameExt], None, None]:
         while True:
             data = self.file.read(OBJ_HEADER_BASE_STRUCT.size)
             if not data:
@@ -196,7 +212,7 @@ def __iter__(self) -> Generator[Message, None, None]:
                 yield from self._parse_container(data)
         self.stop()
 
-    def _parse_container(self, data):
+    def _parse_container(self, data: bytes) -> Generator[Union[Message, UnknownMessage, EthernetFrame, EthernetFrameExt], None, None]:
         if self._tail:
             data = b"".join((self._tail, data))
         try:
@@ -207,7 +223,7 @@ def _parse_container(self, data):
         # Save the remaining data that could not be processed
         self._tail = data[self._pos :]
 
-    def _parse_data(self, data):
+    def _parse_data(self, data: bytes) -> Generator[Union[Message, UnknownMessage, EthernetFrame, EthernetFrameExt], None, None]:
         """Optimized inner loop by making local copies of global variables
         and class members and hardcoding some values."""
         unpack_obj_header_base = OBJ_HEADER_BASE_STRUCT.unpack_from
@@ -221,6 +237,10 @@ def _parse_data(self, data):
         unpack_can_fd_64_msg = CAN_FD_MSG_64_STRUCT.unpack_from
         can_fd_64_msg_size = CAN_FD_MSG_64_STRUCT.size
         unpack_can_error_ext = CAN_ERROR_EXT_STRUCT.unpack_from
+        unpack_ethernet_frame = ETHERNET_FRAME_STRUCT.unpack_from
+        ethernet_frame_msg_size = ETHERNET_FRAME_STRUCT.size
+        unpack_ethernet_frame_ex = ETHERNET_FRAME_EX_STRUCT.unpack_from
+        ethernet_ext_msg_size = ETHERNET_FRAME_EX_STRUCT.size
 
         start_timestamp = self.start_timestamp
         max_pos = len(data)
@@ -351,6 +371,70 @@ def _parse_data(self, data):
                     data=data[pos : pos + valid_bytes],
                     channel=channel - 1,
                 )
+            elif obj_type == ETHERNET_FRAME:
+                members = unpack_ethernet_frame(data, pos)
+                (
+                    sourceAddress,
+                    channel,
+                    destinationAddress,
+                    direction,
+                    frameType,
+                    tpid,
+                    tci,
+                    payloadLength,
+                    _
+                ) = members
+
+                pos += ethernet_frame_msg_size
+                yield EthernetFrame(
+                    timestamp=timestamp,
+                    source_address=sourceAddress,
+                    channel=channel,
+                    destination_address=destinationAddress,
+                    direction=direction,
+                    ether_type=frameType,
+                    tpid=tpid,
+                    tci=tci,
+                    payloadLength=payloadLength,
+                    data=data[pos : pos + payloadLength]
+                )
+
+            elif obj_type == ETHERNET_FRAME_EX:
+                members = unpack_ethernet_frame_ex(data, pos)
+                (
+                    structLength,
+                    flags,
+                    channel,
+                    hardwareChannel,
+                    frameDuration,
+                    frameChecksum,
+                    direction,
+                    frameLength,
+                    frameHandle,
+                    _
+                ) = members
+                
+                pos += ethernet_ext_msg_size
+                yield EthernetFrameExt(
+                    timestamp=timestamp,
+                    struct_length=structLength,
+                    flags=flags,
+                    channel=channel,
+                    hardware_channel=hardwareChannel,
+                    duration=frameDuration,
+                    checksum=frameChecksum,
+                    handle=frameHandle,
+                    length=frameLength,
+                    direction=direction,
+                    data=data[pos : pos + frameLength]
+                )
+
+            else:
+                yield UnknownMessage(
+                    objectType=obj_type,
+                    timestamp=timestamp,
+                    data=data[pos : next_pos]
+                )
 
             pos = next_pos
 
@@ -443,13 +527,50 @@ def _write_header(self, filesize):
         self.file.write(b"\x00" * (FILE_HEADER_SIZE - FILE_HEADER_STRUCT.size))
 
     def on_message_received(self, msg):
+
+        if isinstance(msg, UnknownMessage):
+            data = msg.data
+            self._add_object(msg.objectType, data, msg.timestamp)
+            return
+        
         channel = channel2int(msg.channel)
         if channel is None:
             channel = self.channel
         else:
             # Many interfaces start channel numbering at 0 which is invalid
             channel += 1
 
+        if isinstance(msg, EthernetFrameExt):
+            data = ETHERNET_FRAME_EX_STRUCT.pack(
+                msg.struct_length,
+                msg.flags,
+                channel,
+                msg.hardware_channel if msg.hardware_channel is not None else 0,
+                msg.duration if msg.duration is not None else 0,
+                msg.checksum if msg.checksum is not None else 0,
+                msg.direction if msg.direction is not None else 0,
+                len(msg.data),
+                msg.handle,
+                0,  # reservedEthernetFrameEx
+            )
+            self._add_object(ETHERNET_FRAME_EX, data + msg.data, msg.timestamp)
+            return
+        
+        if isinstance(msg, EthernetFrame):
+            data = ETHERNET_FRAME_STRUCT.pack(
+                msg.source_address,
+                channel,
+                msg.destination_address,
+                msg.direction,
+                msg.type,
+                msg.tpid,
+                msg.tci,
+                len(msg.data),
+                0,  # reservedEthernetFrame
+            )
+            self._add_object(ETHERNET_FRAME, data + msg.data, msg.timestamp)
+            return
+        
         arb_id = msg.arbitration_id
         if msg.is_extended_id:
             arb_id |= CAN_MSG_EXT
diff --git a/can/unknownmessage.py b/can/unknownmessage.py
