Add DLT file transfer packages

README.md

@@ -182,6 +182,7 @@ An complete example which includes the parsing of the ethernet & udp headers can
 
 ## References
 * [Log and Trace Protocol Specification](https://www.autosar.org/fileadmin/standards/foundation/1-3/AUTOSAR_PRS_LogAndTraceProtocol.pdf)
+* [COVESA DLT Filetransfer](https://github.com/COVESA/dlt-daemon/blob/603f0e4bb87478f7d3e95c89b37790e55ff1e4e5/doc/dlt_filetransfer.md)
 
 ## License
 Licensed under either of Apache License, Version 2.0 or MIT license at your option. The corresponding license texts can be found in the LICENSE-APACHE file and the LICENSE-MIT file.

src/control/mod.rs

@@ -1,4 +1,3 @@
-
 /// "Set Log Level" service id
 pub const CMD_ID_SET_LOG_LEVEL: u32 = 0x01;
 /// "Set Log Level" name
@@ -119,7 +118,7 @@ mod test {
     use super::*;
     use proptest::prelude::*;
 
-    proptest!{
+    proptest! {
         #[test]
         fn test_get_control_command_name(
             unknown_id in 0x24..0xFFFu32,
@@ -169,4 +168,4 @@ mod test {
             assert_eq!(Some("CallSWCInjection"), get_control_command_name(sw_injections_id));
         }
     }
-}
+}

src/dlt_header.rs

@@ -307,6 +307,7 @@ impl DltHeader {
 
     ///Deserialize a DltHeader & TpHeader from the given reader.
     #[cfg(feature = "std")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
     pub fn read<T: io::Read + Sized>(reader: &mut T) -> Result<DltHeader, error::ReadError> {
         use crate::error::UnsupportedDltVersionError;
 
@@ -382,6 +383,7 @@ impl DltHeader {
 
     ///Serializes the header to the given writer.
     #[cfg(feature = "std")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
     pub fn write<T: io::Write + Sized>(&self, writer: &mut T) -> Result<(), std::io::Error> {
         {
             let length_be = self.length.to_be_bytes();

src/dlt_typed_payload.rs

@@ -1,4 +1,4 @@
-use crate::{*, verbose::VerboseIter};
+use crate::{verbose::VerboseIter, *};
 
 /// Typed payload of a DLT log message based on the message info in the DLT
 /// extended header.

src/error/dlt_message_length_too_small_error.rs

@@ -18,6 +18,7 @@ impl core::fmt::Display for DltMessageLengthTooSmallError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for DltMessageLengthTooSmallError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         None

src/error/ft_pool_error.rs

@@ -0,0 +1,89 @@
+use super::*;
+use crate::ft::DltFtUInt;
+
+#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum FtPoolError {
+    /// Error re-assembling the stream.
+    FtReassemble(FtReassembleError),
+
+    /// Error if a data packet for an unknown stream is received.
+    DataForUnknownStream { file_serial_number: DltFtUInt },
+
+    /// Error if a end packet for an unknown stream is received.
+    EndForUnknownStream { file_serial_number: DltFtUInt },
+}
+
+impl core::fmt::Display for FtPoolError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use FtPoolError::*;
+        match self {
+            FtReassemble(err) => err.fmt(f),
+            DataForUnknownStream{ file_serial_number } => write!(f, "Received a DLT file transfer 'data' packet from an unknown stream with file_serial_number {file_serial_number:?}."),
+            EndForUnknownStream{ file_serial_number } => write!(f, "Received a DLT file transfer 'end' packet from an unknown stream with file_serial_number {file_serial_number:?}."),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl std::error::Error for FtPoolError {}
+
+impl From<FtReassembleError> for FtPoolError {
+    fn from(value: FtReassembleError) -> Self {
+        FtPoolError::FtReassemble(value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    /*use super::FtPoolError::*;
+
+    #[test]
+    fn debug() {
+        let err = AllocationFailure { len: 0 };
+        let _ = format!("{err:?}");
+    }
+
+    #[test]
+    fn clone_eq_hash_ord() {
+        use core::cmp::Ordering;
+        use std::collections::hash_map::DefaultHasher;
+        use std::hash::{Hash, Hasher};
+
+        let err = AllocationFailure { len: 0 };
+        assert_eq!(err, err.clone());
+        let hash_a = {
+            let mut hasher = DefaultHasher::new();
+            err.hash(&mut hasher);
+            hasher.finish()
+        };
+        let hash_b = {
+            let mut hasher = DefaultHasher::new();
+            err.clone().hash(&mut hasher);
+            hasher.finish()
+        };
+        assert_eq!(hash_a, hash_b);
+        assert_eq!(Ordering::Equal, err.cmp(&err));
+        assert_eq!(Some(Ordering::Equal), err.partial_cmp(&err));
+    }
+
+    #[test]
+    fn fmt() {
+        let tests = [
+            (UnalignedTpPayloadLen { offset: 1, payload_len: 2 }, "Payload length 2 of SOMEIP TP segment (offset 1) is not a multiple of 16. This is only allowed for TP packets where the 'more segements' flag is not set."),
+            (SegmentTooBig { offset: 1, payload_len: 2, max: 3, }, "Overall length of TP segment (offset 1, payload len: 2) bigger then the maximum allowed size of 3."),
+            (ConflictingEnd { previous_end: 1, conflicting_end: 2, }, "Received a TP package (offset + len: 2) which conflicts a package that previously set the end to 1."),
+            (AllocationFailure { len: 0 }, "Faield to allocate 0 bytes of memory to reconstruct the SOMEIP TP packets."),
+        ];
+        for test in tests {
+            assert_eq!(format!("{}", test.0), test.1);
+        }
+    }
+
+    #[test]
+    fn source() {
+        use std::error::Error;
+        assert!(AllocationFailure { len: 0 }.source().is_none());
+    }
+     */
+}

src/error/ft_reassemble_error.rs

@@ -0,0 +1,106 @@
+#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum FtReassembleError {
+    /// Error if the number of bytes of data in a "DLT file transfer" packet
+    /// is not matching the original in the header specified buffer size.
+    DataLenNotMatchingBufferSize {
+        header_buffer_len: u64,
+        data_pkt_len: u64,
+        data_pkt_nr: u64,
+        number_of_packages: u64,
+    },
+
+    /// Error if the number of packages & buffer len do not match the file_size.
+    InconsitantHeaderLenValues {
+        file_size: u64,
+        number_of_packages: u64,
+        buffer_size: u64,
+    },
+
+    /// Error if a data package with an unexpected package nr is received.
+    UnexpectedPackageNrInDataPkg {
+        expected_nr_of_packages: u64,
+        package_nr: u64,
+    },
+
+    /// File transfer is too big to be stored in memory (if the file size
+    /// exceeds the platform pointer width).
+    FileSizeTooBig {
+        file_size: u64,
+        max_allowed: u64,
+    },
+
+    /// Error if not enough memory could be allocated to store the file in memory.
+    AllocationFailure { len: usize },
+}
+
+impl core::fmt::Display for FtReassembleError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use FtReassembleError::*;
+        match self {
+            DataLenNotMatchingBufferSize{ header_buffer_len, data_pkt_len, data_pkt_nr, number_of_packages } => write!(f, "Payload length {data_pkt_len} of DLT file transfer data packet (nr {data_pkt_nr} of {number_of_packages}) is not matching the buffer len {header_buffer_len} set by the header packet."),
+            InconsitantHeaderLenValues{ file_size, number_of_packages, buffer_size: buffer_len } => write!(f, "DLT file transfer header packet 'file size' {file_size} is inconsistant with the 'buffer size' {buffer_len} and 'number of packages' {number_of_packages}"),
+            UnexpectedPackageNrInDataPkg { expected_nr_of_packages, package_nr } => write!(f, "Received a DLT file transfer data packet with the unexpected package number {package_nr} (expected number of packages based on header package is {expected_nr_of_packages})."),
+            FileSizeTooBig { file_size, max_allowed } => write!(f, "DLT filetransfer file size {file_size} exceeds the supported maximum of {max_allowed}."),
+            AllocationFailure { len } => write!(f, "Failed to allocate {len} bytes of memory to reconstruct the SOMEIP TP packets."),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+impl std::error::Error for FtReassembleError {}
+
+#[cfg(test)]
+mod tests {
+    /*use super::FtReassembleError::*;
+
+
+    #[test]
+    fn debug() {
+        let err = AllocationFailure { len: 0 };
+        let _ = format!("{err:?}");
+    }
+
+    #[test]
+    fn clone_eq_hash_ord() {
+        use core::cmp::Ordering;
+        use std::collections::hash_map::DefaultHasher;
+        use std::hash::{Hash, Hasher};
+
+        let err = AllocationFailure { len: 0 };
+        assert_eq!(err, err.clone());
+        let hash_a = {
+            let mut hasher = DefaultHasher::new();
+            err.hash(&mut hasher);
+            hasher.finish()
+        };
+        let hash_b = {
+            let mut hasher = DefaultHasher::new();
+            err.clone().hash(&mut hasher);
+            hasher.finish()
+        };
+        assert_eq!(hash_a, hash_b);
+        assert_eq!(Ordering::Equal, err.cmp(&err));
+        assert_eq!(Some(Ordering::Equal), err.partial_cmp(&err));
+    }
+
+    #[test]
+    fn fmt() {
+        let tests = [
+            (UnalignedTpPayloadLen { offset: 1, payload_len: 2 }, "Payload length 2 of SOMEIP TP segment (offset 1) is not a multiple of 16. This is only allowed for TP packets where the 'more segements' flag is not set."),
+            (SegmentTooBig { offset: 1, payload_len: 2, max: 3, }, "Overall length of TP segment (offset 1, payload len: 2) bigger then the maximum allowed size of 3."),
+            (ConflictingEnd { previous_end: 1, conflicting_end: 2, }, "Received a TP package (offset + len: 2) which conflicts a package that previously set the end to 1."),
+            (AllocationFailure { len: 0 }, "Faield to allocate 0 bytes of memory to reconstruct the SOMEIP TP packets."),
+        ];
+        for test in tests {
+            assert_eq!(format!("{}", test.0), test.1);
+        }
+    }
+
+    #[test]
+    fn source() {
+        use std::error::Error;
+        assert!(AllocationFailure { len: 0 }.source().is_none());
+    }
+     */
+}

src/error/mod.rs

@@ -1,6 +1,12 @@
 mod dlt_message_length_too_small_error;
 pub use dlt_message_length_too_small_error::*;
 
+mod ft_pool_error;
+pub use ft_pool_error::*;
+
+mod ft_reassemble_error;
+pub use ft_reassemble_error::*;
+
 mod layer;
 pub use layer::*;
 
@@ -11,6 +17,7 @@ mod range_error;
 pub use range_error::*;
 
 mod read_error;
+#[cfg(feature = "std")]
 pub use read_error::*;
 
 mod storage_header_start_pattern_error;

src/error/packet_slice_error.rs

@@ -27,6 +27,7 @@ impl core::fmt::Display for PacketSliceError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for PacketSliceError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         use PacketSliceError::*;

src/error/range_error.rs

@@ -6,6 +6,7 @@ pub enum RangeError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for RangeError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         None

src/error/read_error.rs

@@ -1,7 +1,9 @@
+#[cfg(feature = "std")]
 use super::*;
 
 ///Errors that can occure on reading a dlt header.
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 #[derive(Debug)]
 pub enum ReadError {
     /// Error if the slice is smaller then dlt length field or minimal size.
@@ -22,6 +24,7 @@ pub enum ReadError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for ReadError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         use ReadError::*;
@@ -36,6 +39,7 @@ impl std::error::Error for ReadError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl core::fmt::Display for ReadError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         use ReadError::*;
@@ -53,13 +57,15 @@ impl core::fmt::Display for ReadError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl From<StorageHeaderStartPatternError> for ReadError {
     fn from(err: StorageHeaderStartPatternError) -> ReadError {
         ReadError::StorageHeaderStartPattern(err)
     }
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl From<PacketSliceError> for ReadError {
     fn from(err: PacketSliceError) -> ReadError {
         use PacketSliceError as I;
@@ -72,6 +78,7 @@ impl From<PacketSliceError> for ReadError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl From<std::io::Error> for ReadError {
     fn from(err: std::io::Error) -> ReadError {
         ReadError::IoError(err)

src/error/storage_header_start_pattern_error.rs

@@ -19,6 +19,7 @@ impl core::fmt::Display for StorageHeaderStartPatternError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for StorageHeaderStartPatternError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         None

src/error/typed_payload_error.rs

@@ -15,6 +15,7 @@ pub enum TypedPayloadError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for TypedPayloadError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         None

src/error/unexpected_end_of_slice_error.rs

@@ -26,6 +26,7 @@ impl core::fmt::Display for UnexpectedEndOfSliceError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for UnexpectedEndOfSliceError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         None

src/error/unsupported_dlt_version_error.rs

@@ -20,6 +20,7 @@ impl core::fmt::Display for UnsupportedDltVersionError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for UnsupportedDltVersionError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         None

src/error/verbose_decode_error.rs

@@ -59,6 +59,7 @@ impl core::fmt::Display for VerboseDecodeError {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl std::error::Error for VerboseDecodeError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         use VerboseDecodeError::*;