From 42ce8dbaeb46245b48ab10a0abfd44947496e00c Mon Sep 17 00:00:00 2001
From: TIM ANDERSON <timothyanderson096@gmail.com>
Date: Mon, 26 Oct 2026 15:22:47 +1000
Subject: [PATCH] fix(mf4): read packed scalar error-frame payloads

---
 can/io/mf4.py                  |  7 +--
 doc/changelog.d/1913.fixed.rst |  2 +
 test/logformats_test.py        | 78 +++++++++++++++++++++++++++++++++-
 3 files changed, 83 insertions(+), 4 deletions(-)
 create mode 100644 doc/changelog.d/1913.fixed.rst

diff --git a/can/io/mf4.py b/can/io/mf4.py
index fcde2e193..854842c92 100644
--- a/can/io/mf4.py
+++ b/can/io/mf4.py
@@ -415,9 +415,10 @@ def __iter__(self) -> Generator[Message, None, None]:
                         and "CAN_ErrorFrame.DataBytes" in names
                     ):
                         data_length = int(data["CAN_ErrorFrame.DataLength"][i])
-                        kv["data"] = data["CAN_ErrorFrame.DataBytes"][i][
-                            :data_length
-                        ].tobytes()
+                        # A one-record slice preserves packed scalar byte order.
+                        kv["data"] = data["CAN_ErrorFrame.DataBytes"][
+                            i : i + 1
+                        ].tobytes()[:data_length]
 
                     yield Message(**kv)
 
diff --git a/doc/changelog.d/1913.fixed.rst b/doc/changelog.d/1913.fixed.rst
new file mode 100644
index 000000000..6aa03d8da
--- /dev/null
+++ b/doc/changelog.d/1913.fixed.rst
@@ -0,0 +1,2 @@
+Fixed MF4 log reading crashing when CAN error-frame payloads are stored as packed
+scalars instead of byte arrays. Payload length and byte order are preserved.
diff --git a/test/logformats_test.py b/test/logformats_test.py
index 42ed29b13..5a1cab94f 100644
--- a/test/logformats_test.py
+++ b/test/logformats_test.py
@@ -27,7 +27,7 @@
 from parameterized import parameterized
 
 import can.io
-from can.io import asc, blf
+from can.io import asc, blf, mf4
 
 from .data.example_data import (
     TEST_COMMENTS,
@@ -993,6 +993,82 @@ def _setup_instance(self):
 class TestMF4FileFormat(ReaderWriterTest):
     """Tests can.MF4Writer and can.MF4Reader"""
 
+    @parameterized.expand(
+        [
+            ("reported_scalar", "<u4", b"\x00\x00\x00\x01", 4, False),
+            ("little_endian", "<u4", b"\x04\x03\x02\x01", 3, False),
+            ("big_endian", ">u4", b"\x01\x02\x03\x04", 3, False),
+            ("empty_scalar", "<u4", b"\x04\x03\x02\x01", 0, False),
+            ("one_byte_scalar", "u1", b"\xab", 1, False),
+            ("byte_array", "(8,)u1", bytes(range(8)), 4, False),
+            ("fd_array_truncated", "(64,)u1", bytes(range(64)), 12, True),
+            ("fd_array_full", "(64,)u1", bytes(range(64)), 64, True),
+        ]
+    )
+    def test_error_frame_payload(self, name, storage, payload, length, fd):
+        # Build the file with asammdf, since MF4Writer always uses a byte array.
+        dtype = mf4.np.dtype(
+            [
+                (
+                    field,
+                    (
+                        storage
+                        if field == "CAN_ErrorFrame.DataBytes"
+                        else mf4.ERR_DTYPE[field]
+                    ),
+                )
+                for field in mf4.ERR_DTYPE.names
+            ]
+        )
+        samples = mf4.np.zeros(2, dtype=dtype)
+        payloads = [payload, payload[::-1]]
+        for index, raw in enumerate(payloads):
+            samples["CAN_ErrorFrame.DataBytes"][index] = mf4.np.frombuffer(
+                raw, dtype=mf4.np.dtype(storage)
+            )[0]
+        samples["CAN_ErrorFrame.DataLength"] = length
+        samples["CAN_ErrorFrame.ID"] = 0x12345
+        samples["CAN_ErrorFrame.IDE"] = 1
+        samples["CAN_ErrorFrame.BusChannel"] = 2
+        samples["CAN_ErrorFrame.EDL"] = int(fd)
+        samples["CAN_ErrorFrame.BRS"] = int(fd)
+        samples["CAN_ErrorFrame.ESI"] = int(fd)
+        samples["CAN_ErrorFrame.Dir"] = 1
+
+        path = Path(self.test_file_name).with_suffix(".mf4")
+        self.addCleanup(path.unlink, missing_ok=True)
+        start = datetime(2024, 1, 1, tzinfo=timezone.utc)
+        with asammdf.MDF(version="4.10") as mdf:
+            mdf.header.start_time = start
+            mdf.append(
+                asammdf.Signal(
+                    name="CAN_ErrorFrame",
+                    samples=samples,
+                    timestamps=mf4.np.array([1.5, 2.5]),
+                    source=mf4.SourceInformation(
+                        source_type=mf4.SOURCE_BUS, bus_type=mf4.BUS_TYPE_CAN
+                    ),
+                )
+            )
+            mdf.groups[0].channel_group.flags |= mf4.FLAG_CG_BUS_EVENT
+            mdf.save(path, overwrite=True)
+
+        with can.MF4Reader(path) as reader:
+            messages = list(reader)
+        self.assertEqual(len(messages), 2)
+        for index, msg in enumerate(messages):
+            self.assertEqual(msg.data, payloads[index][:length])
+            self.assertEqual(msg.dlc, length)
+            self.assertEqual(msg.timestamp, start.timestamp() + 1.5 + index)
+            self.assertEqual(msg.arbitration_id, 0x12345)
+            self.assertEqual(msg.channel, 2)
+            self.assertTrue(msg.is_error_frame)
+            self.assertTrue(msg.is_extended_id)
+            self.assertFalse(msg.is_rx)
+            self.assertEqual(msg.is_fd, fd)
+            self.assertEqual(msg.bitrate_switch, fd)
+            self.assertEqual(msg.error_state_indicator, fd)
+
     def _setup_instance(self):
         super()._setup_instance_helper(
             can.MF4Writer,