Merge pull request 'prepare v0.16.0' (#165) from prep-v0.16.0 into main

Reviewed-on: #165

.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.68.2
+      - uses: dtolnay/rust-toolchain@1.83
       - run: cargo check --release
 
   cross-check:
@@ -61,7 +61,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
-      - run: cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]'
+      - run: RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options" cargo +nightly doc --all-features
 
   clippy:
     name: Clippy

CHANGELOG.md

@@ -8,6 +8,135 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+# [v0.16.0] 2025-09-24
+
+- Bump Rust MSRV to v1.83
+
+## Changed
+
+- `PusTcCreator` has its own `service`, `subservice` and `apid` methods and does not require trait
+  imports anymore.
+- CFDP NAK PDU `SegmentRequestIter` is not generic over the file size anymore. Instead, the
+  iterator returns pairs of `u64` for both large and normal file size.
+- `PusVersion::VersionNotSupported` contains raw version number instead of `PusVersion` enum now
+  to make it more flexible.
+- `pus_version` API now returns a `Result<PusVersion, u8>` instead of a `PusVersion` to allow
+  modelling invalid version numbers properly.
+- Renamed `CcsdsPacket::total_len` to `CcsdsPacket::packet_len`
+- Renamed `SequenceCountProvider` to `SequenceCounter`
+- Renamed `SeqCountProviderSimple` to `SequenceCounterSimple`
+- Renamed `CcsdsSimpleSeqCountProvider` to `SequenceCounterCcsdsSimple`
+- Renamed `SeqCountProviderSync` to `SequenceCounterSync`
+- Renamed `PusPacket::opt_crc16` to `PusPacket::checksum`
+- Renamed `PacketSequenceCtrl` to `PacketSequenceControl`
+- ECSS checksum generation is now optional as specified in the standard. Added `has_checksum`
+  parameters for ECSS TM/TC creators and readers to reflect this.
+- APID is represented by `arbitrary-int::u11` while the sequence count is represented by
+  `arbitrary-int::u14`. A lot of corresponding checks were removed because the type now ensure
+  value validity.
+- ACK field changed from `u8` to `AckFlags` structure.
+- PUS version raw representation is `u4` now.
+- SC time reference status representation is `u4` now.
+- Renamed `ptype` to `packet_type`
+- Renamed `PduHeader::new_no_file_data` to `PduHeader::new_for_file_directive`
+- Renamd `FinishedPduCreator::new_generic` to `new` and `new_default` to `new_no_error`
+
+## Removed
+
+- `PusVersion::Invalid`, which will be modelled with `Result<PusVersion, u8>` now.
+
+## Added
+
+- `cfdp::pdu::ack::InvalidAckedDirectiveCodeError` which is returned by the `AckPdu` constructor.
+- `cfdp::pdu::nak::NakPduCreatorWithReservedSegReqsBuf` constructor which exposes the segment
+  request buffer mutably to avoid the need for a separate segment request buffer.
+- `SpHeader::packet_len` direct method.
+- `AckFlags` which is implemented with `bitbybit::bitfield`
+- `ApidOutOfRangeError` and `SequenceCountOutOfRangeError`
+- Added PUS A legacy support for telecommands inside the `ecss.tc_pus_a` module
+- Added `SequenceCounter::increment_mut` and `SequenceCounter::get_and_increment_mut`
+- Implemented `SequenceCounter` for `Atomic` unsigned types and references of them
+- `PusPacket::has_checksum` and `WritablePusPacket::has_checksum`
+- PUS TC builder API, either via `PusTcBuilder::new`, or `PusTcCreator::builder`
+
+# [v0.15.0] 2025-07-18
+
+## Added
+
+- `PusTcCreatorWithReservedAppData` and `PusTmCreatorWithReservedSourceData` constructor variants
+  which allow writing source/app data into the serialization buffer directly without
+  requiring an extra buffer.
+
+# [v0.14.0] 2025-05-10
+
+## Changed
+
+- Moved CRC constants/implementations to dedicated `crc` module.
+- `crc::CRC_CCITT_FALSE_NO_TABLE` and `crc::CRC_CCITT_FALSE_BIG_TABLE` variants.
+- Renamed `PusPacket::crc16` to `PusPacket::opt_crc16`.
+
+## Added
+
+- `WritablePusPacket::write_to_bytes_crc_no_table` and `WritablePusPacket::write_to_bytes_no_crc`
+  variants.
+- `PusTmReader::new_crc_no_table` and `PusTcReader::new_crc_no_table` variants.
+- `crc16` methods for PUS TM and PUS TC reader.
+- PUS TM and PUS TC reader now return the reader instance directly instead of a tuple of the reader
+  and the read size. The instance `total_len` method can be used to retrieve the read lenght.
+
+# [v0.13.1] 2025-03-21
+
+- Bugfix due to operator precendence for `PusTcSecondaryHeader::pus_version`,
+  `PusTcSecondaryHeaderWithoutTimestamp::pus_version`, `CdsTime::from_bytes_with_u16_days` and
+  `CdsTime::from_bytes_with_u24_days`
+
+# [v0.13.0] 2024-11-08
+
+- Bumped MSRV to 1.81.0
+- Bump `zerocopy` to v0.8.0
+- Bump `thiserror` to v2.0.0
+
+## Changed
+
+- Migrated all Error implementations to thiserror, improved some naming and error handling in
+  general
+
+# [v0.12.0] 2024-09-10
+
+- Bumped MSRV to 1.70.0
+
+## Added
+
+- Added new `cfdp::tlv::TlvOwned` type which erases the lifetime and is clonable.
+- Dedicated `cfdp::tlv::TlvLvDataTooLarge` error struct for APIs where this is the only possible
+  API error.
+- Added File Data PDU API which expects the expected file data size and then exposes the unwritten
+  file data field as a mutable slice. This allows to read data from the virtual file system
+  API to the file data buffer without an intermediate buffer.
+- Generic `EofPdu::new` constructor.
+- Added generic sequence counter module.
+- Added `MsgToUserTlv::to_tlv` converter which reduced the type and converts
+  it to a generic `Tlv`.
+- Implemented `From<MsgToUserTlv> for Tlv` converter trait.
+- Added CFDP maximum file segment length calculator method `calculate_max_file_seg_len_for_max_packet_len_and_pdu_header`
+
+## Added and Changed
+
+- Added new `ReadableTlv` to avoid some boilerplate code and have a common abstraction implemented
+  for both `Tlv` and `TlvOwned` to read the raw TLV data field and its length.
+- Replaced `cfdp::tlv::TlvLvError` by `cfdp::tlv::TlvLvDataTooLarge` where applicable.
+
+## Fixed
+
+- Fixed an error in the EOF writer which wrote the fault location to the wrong buffer position.
+- cfdp `ConditionCode::CheckLimitReached` previous had the wrong numerical value of `0b1001` (9)
+  and now has the correct value of `0b1010` (10).
+
+## Changed
+
+- Minor documentation build updates.
+- Increased delegate version range to v0.13
+
 # [v0.11.2] 2024-05-19
 
 - Bumped MSRV to 1.68.2
@@ -514,3 +643,11 @@ The timestamp of `PusTm` is now optional. See Added and Changed section for deta
 
 Initial release with CCSDS Space Packet Primary Header implementation and basic PUS TC and TM
 implementations.
+
+[unreleased]: https://egit.irs.uni-stuttgart.de/rust/spacepackets/compare/v0.16.0...HEAD
+[v0.16.0]: https://egit.irs.uni-stuttgart.de/rust/spacepackets/compare/v0.15.0...v0.16.0
+[v0.15.0]: https://egit.irs.uni-stuttgart.de/rust/spacepackets/compare/v0.14.0...v0.15.0
+[v0.14.0]: https://egit.irs.uni-stuttgart.de/rust/spacepackets/compare/v0.13.1...v0.14.0
+[v0.13.1]: https://egit.irs.uni-stuttgart.de/rust/spacepackets/compare/v0.13.0...v0.13.1
+[v0.13.0]: https://egit.irs.uni-stuttgart.de/rust/spacepackets/compare/v0.12.0...v0.13.0
+[v0.12.0]: https://egit.irs.uni-stuttgart.de/rust/spacepackets/compare/v0.11.2...v0.12.0

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "spacepackets"
-version = "0.11.2"
+version = "0.16.0"
 edition = "2021"
-rust-version = "1.68.2"
+rust-version = "1.83"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 description = "Generic implementations for various CCSDS and ECSS packet standards"
 homepage = "https://egit.irs.uni-stuttgart.de/rust/spacepackets"
@@ -14,57 +14,33 @@ categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-sup
 
 [dependencies]
 crc = "3"
-delegate = ">=0.8, <0.11"
+delegate = ">=0.8, <=0.13"
+paste = "1"
+zerocopy = { version = "0.8", features = ["derive"] }
+thiserror = { version = "2", default-features = false }
+num_enum = { version = ">0.5, <=0.7", default-features = false }
+num-traits = { version = "0.2", default-features = false }
+serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
+arbitrary-int = { version = "2" }
+portable-atomic = "1"
+bitbybit = "1.4"
 
-[dependencies.zerocopy]
-version = "0.7"
-features = ["derive"]
-
-[dependencies.thiserror]
-version = "1"
-optional = true
-
-[dependencies.num_enum]
-version = ">0.5, <=0.7"
-default-features = false
-
-[dependencies.serde]
-version = "1"
-optional = true
-default-features = false
-features = ["derive"]
-
-[dependencies.time]
-version = "0.3"
-default-features = false
-optional = true
-
-[dependencies.chrono]
-version = "0.4"
-default-features = false
-optional = true
-
-[dependencies.num-traits]
-version = "0.2"
-default-features = false
-
-[dependencies.defmt]
-version = "0.3"
-optional = true
-
-[dev-dependencies]
-postcard = "1"
-chrono = "0.4"
+time = { version = "0.3", default-features = false, optional = true }
+chrono = { version = "0.4", default-features = false, optional = true }
+defmt = { version = "1", default-features = false, optional = true }
 
 [features]
 default = ["std"]
-std = ["chrono/std", "chrono/clock", "alloc", "thiserror"]
-serde = ["dep:serde", "chrono/serde"]
-alloc = ["postcard/alloc", "chrono/alloc"]
-chrono = ["dep:chrono"]
+std = ["alloc", "chrono/std", "chrono/clock", "thiserror/std"]
+defmt = ["dep:defmt", "arbitrary-int/defmt"]
+serde = ["dep:serde", "chrono?/serde", "arbitrary-int/serde"]
+alloc = ["chrono?/alloc", "defmt?/alloc", "serde?/alloc"]
 timelib = ["dep:time"]
-defmt = ["dep:defmt"]
+
+[dev-dependencies]
+postcard = { version = "1", features = ["alloc"] }
+chrono = "0.4"
 
 [package.metadata.docs.rs]
 all-features = true
-rustdoc-args = ["--cfg", "docs_rs", "--generate-link-to-definition"]
+rustdoc-args = ["--generate-link-to-definition"]

FUNDING.yml

@@ -0,0 +1 @@
+github: robamu

README.md

@@ -1,7 +1,7 @@
 [![Crates.io](https://img.shields.io/crates/v/spacepackets)](https://crates.io/crates/spacepackets)
 [![docs.rs](https://img.shields.io/docsrs/spacepackets)](https://docs.rs/spacepackets)
 [![ci](https://github.com/us-irs/spacepackets-rs/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/us-irs/spacepackets-rs/actions/workflows/ci.yml)
-[![coverage](https://shields.io/endpoint?url=https://absatsw.irs.uni-stuttgart.de/projects/spacepackets/coverage-rs/latest/coverage.json)](https://absatsw.irs.uni-stuttgart.de/projects/spacepackets/coverage-rs/latest/index.html)
+[![matrix chat](https://img.shields.io/matrix/sat-rs%3Amatrix.org)](https://matrix.to/#/#sat-rs:matrix.org)
 
 ECSS and CCSDS Spacepackets
 ======
@@ -51,16 +51,14 @@ usage examples.
 
 # Coverage
 
-Coverage was generated using [`grcov`](https://github.com/mozilla/grcov). If you have not done so
-already, install the `llvm-tools-preview`:
+Coverage can be generated using [`llvm-cov`](https://github.com/taiki-e/cargo-llvm-cov). If you have not done so
+already, install the tool:
 
 ```sh
-rustup component add llvm-tools-preview
-cargo install grcov --locked
+cargo +stable install cargo-llvm-cov --locked
 ```
 
-After that, you can simply run `coverage.py` to test the project with coverage. You can optionally
-supply the `--open` flag to open the coverage report in your webbrowser.
+After this, you can run `cargo llvm-cov nextest` to run all the tests and display coverage.
 
 # Miri
 

automation/Jenkinsfile

@@ -21,7 +21,9 @@ pipeline {
     }
     stage('Docs') {
         steps {
-          sh 'cargo +nightly doc --all-features'
+          sh """
+            RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options" cargo +nightly doc --all-features
+          """
         }
     }
     stage('Rustfmt') {

coverage.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-import os
-import logging
-import argparse
-import webbrowser
-
-
-_LOGGER = logging.getLogger()
-
-
-def generate_cov_report(open_report: bool, format: str):
-    logging.basicConfig(level=logging.INFO)
-    os.environ["RUSTFLAGS"] = "-Cinstrument-coverage"
-    os.environ["LLVM_PROFILE_FILE"] = "target/coverage/%p-%m.profraw"
-    _LOGGER.info("Executing tests with coverage")
-    os.system("cargo test --all-features")
-
-    out_path = "./target/debug/coverage"
-    if format == "lcov":
-        out_path = "./target/debug/lcov.info"
-    os.system(
-        f"grcov . -s . --binary-path ./target/debug/ -t {format} --branch --ignore-not-existing "
-        f"-o {out_path}"
-    )
-    if format == "lcov":
-        os.system(
-            "genhtml -o ./target/debug/coverage/ --show-details --highlight --ignore-errors source "
-            "--legend ./target/debug/lcov.info"
-        )
-    if open_report:
-        coverage_report_path = os.path.abspath("./target/debug/coverage/index.html")
-        webbrowser.open_new_tab(coverage_report_path)
-    _LOGGER.info("Done")
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Generate coverage report and optionally open it in a browser"
-    )
-    parser.add_argument(
-        "--open", action="store_true", help="Open the coverage report in a browser"
-    )
-    parser.add_argument(
-        "--format",
-        choices=["html", "lcov"],
-        default="html",
-        help="Choose report format (html or lcov)",
-    )
-    args = parser.parse_args()
-    generate_cov_report(args.open, args.format)
-
-
-if __name__ == "__main__":
-    main()

justfile

@@ -0,0 +1,31 @@
+all: check build test clippy fmt docs coverage
+
+clippy:
+  cargo clippy -- -D warnings
+
+fmt:
+  cargo fmt --all -- --check
+
+check:
+  cargo check --all-features
+
+test:
+  cargo nextest r --all-features
+  cargo test --doc
+
+build:
+  cargo build --all-features
+
+docs:
+  export RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options"
+  cargo +nightly doc --all-features
+
+docs-html:
+  export RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options"
+  cargo +nightly doc --all-features --open
+
+coverage:
+  cargo llvm-cov nextest
+
+coverage-html:
+  cargo llvm-cov nextest --html --open

release-checklist.md

@@ -4,7 +4,9 @@ Checklist for new releases
 # Pre-Release
 
 1. Make sure any new modules are documented sufficiently enough and check docs with
-   `cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]' --open`.
+   `RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options" cargo +nightly doc --all-features --open`
+   or `cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docsrs" --generate-link-to-definition"]' --open`
+   (was problematic on more recent nightly versions).
 2. Bump version specifier in `Cargo.toml`.
 3. Update `CHANGELOG.md`: Convert `unreleased` section into version section with date and add new
    `unreleased` section.

src/cfdp/lv.rs

@@ -1,5 +1,4 @@
 //! Generic CFDP length-value (LV) abstraction as specified in CFDP 5.1.8.
-use crate::cfdp::TlvLvError;
 use crate::ByteConversionError;
 use core::str::Utf8Error;
 #[cfg(feature = "serde")]
@@ -7,6 +6,8 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "std")]
 use std::string::String;
 
+use super::TlvLvDataTooLargeError;
+
 pub const MIN_LV_LEN: usize = 1;
 
 /// Generic CFDP length-value (LV) abstraction as specified in CFDP 5.1.8.
@@ -62,10 +63,12 @@ pub(crate) fn generic_len_check_deserialization(
 }
 
 impl<'data> Lv<'data> {
+    pub const MIN_LEN: usize = MIN_LV_LEN;
+
     #[inline]
-    pub fn new(data: &[u8]) -> Result<Lv, TlvLvError> {
+    pub fn new(data: &[u8]) -> Result<Lv<'_>, TlvLvDataTooLargeError> {
         if data.len() > u8::MAX as usize {
-            return Err(TlvLvError::DataTooLarge(data.len()));
+            return Err(TlvLvDataTooLargeError(data.len()));
         }
         Ok(Lv {
             data,
@@ -85,7 +88,7 @@ impl<'data> Lv<'data> {
     /// Helper function to build a string LV. This is especially useful for the file or directory
     /// path LVs
     #[inline]
-    pub fn new_from_str(str_slice: &str) -> Result<Lv, TlvLvError> {
+    pub fn new_from_str(str_slice: &str) -> Result<Lv<'_>, TlvLvDataTooLargeError> {
         Self::new(str_slice.as_bytes())
     }
 
@@ -93,7 +96,7 @@ impl<'data> Lv<'data> {
     /// path LVs
     #[cfg(feature = "std")]
     #[inline]
-    pub fn new_from_string(string: &'data String) -> Result<Lv<'data>, TlvLvError> {
+    pub fn new_from_string(string: &'data String) -> Result<Lv<'data>, TlvLvDataTooLargeError> {
         Self::new(string.as_bytes())
     }
 
@@ -177,10 +180,10 @@ impl<'data> Lv<'data> {
 
 #[cfg(test)]
 pub mod tests {
-    use super::*;
     use alloc::string::ToString;
 
-    use crate::cfdp::TlvLvError;
+    use super::*;
+
     use crate::ByteConversionError;
     use std::string::String;
 
@@ -271,15 +274,11 @@ pub mod tests {
         let lv = Lv::new(&data_big);
         assert!(lv.is_err());
         let error = lv.unwrap_err();
-        if let TlvLvError::DataTooLarge(size) = error {
-            assert_eq!(size, u8::MAX as usize + 1);
+        assert_eq!(error.0, u8::MAX as usize + 1);
         assert_eq!(
             error.to_string(),
             "data with size 256 larger than allowed 255 bytes"
         );
-        } else {
-            panic!("invalid exception {:?}", error)
-        }
     }
 
     #[test]

src/cfdp/mod.rs

@@ -1,11 +1,8 @@
 //! Low-level CCSDS File Delivery Protocol (CFDP) support according to [CCSDS 727.0-B-5](https://public.ccsds.org/Pubs/727x0b5.pdf).
 use crate::ByteConversionError;
-use core::fmt::{Display, Formatter};
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-#[cfg(feature = "std")]
-use std::error::Error;
 
 pub mod lv;
 pub mod pdu;
@@ -16,36 +13,40 @@ pub const CFDP_VERSION_2_NAME: &str = "CCSDS 727.0-B-5";
 /// Currently, only this version is supported.
 pub const CFDP_VERSION_2: u8 = 0b001;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
 #[repr(u8)]
 pub enum PduType {
     FileDirective = 0,
     FileData = 1,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
 #[repr(u8)]
 pub enum Direction {
     TowardsReceiver = 0,
     TowardsSender = 1,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
 #[repr(u8)]
 pub enum TransmissionMode {
     Acknowledged = 0,
     Unacknowledged = 1,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
 #[repr(u8)]
 pub enum CrcFlag {
     NoCrc = 0,
@@ -71,9 +72,10 @@ impl From<CrcFlag> for bool {
 }
 
 /// Always 0 and ignored for File Directive PDUs (CCSDS 727.0-B-5 P.75)
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
 #[repr(u8)]
 pub enum SegmentMetadataFlag {
     NotPresent = 0,
@@ -81,18 +83,20 @@ pub enum SegmentMetadataFlag {
 }
 
 /// Always 0 and ignored for File Directive PDUs (CCSDS 727.0-B-5 P.75)
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
 #[repr(u8)]
 pub enum SegmentationControl {
     NoRecordBoundaryPreservation = 0,
     WithRecordBoundaryPreservation = 1,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u3, exhaustive = false)]
 #[repr(u8)]
 pub enum FaultHandlerCode {
     NoticeOfCancellation = 0b0001,
@@ -101,9 +105,10 @@ pub enum FaultHandlerCode {
     AbandonTransaction = 0b0100,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u4, exhaustive = false)]
 #[repr(u8)]
 pub enum ConditionCode {
     /// This is not an error condition for which a faulty handler override can be specified
@@ -116,7 +121,7 @@ pub enum ConditionCode {
     FileSizeError = 0b0110,
     NakLimitReached = 0b0111,
     InactivityDetected = 0b1000,
-    CheckLimitReached = 0b1001,
+    CheckLimitReached = 0b1010,
     UnsupportedChecksumType = 0b1011,
     /// Not an actual fault condition for which fault handler overrides can be specified
     SuspendRequestReceived = 0b1110,
@@ -124,9 +129,10 @@ pub enum ConditionCode {
     CancelRequestReceived = 0b1111,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
 #[repr(u8)]
 pub enum LargeFileFlag {
     /// 32 bit maximum file size and FSS size
@@ -136,9 +142,10 @@ pub enum LargeFileFlag {
 }
 
 /// Transaction status for the ACK PDU field according to chapter 5.2.4 of the CFDP standard.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u2, exhaustive = true)]
 #[repr(u8)]
 pub enum TransactionStatus {
     /// Transaction is not currently active and the CFDP implementation does not retain a
@@ -176,76 +183,43 @@ impl Default for ChecksumType {
 
 pub const NULL_CHECKSUM_U32: [u8; 4] = [0; 4];
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[error("data with size {0} larger than allowed {max} bytes", max = u8::MAX)]
+pub struct TlvLvDataTooLargeError(pub usize);
+
+/// First value: Found value. Second value: Expected value if there is one.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[error("invalid TLV type field, found {found}, expected {expected:?}")]
+pub struct InvalidTlvTypeFieldError {
+    found: u8,
+    expected: Option<u8>,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum TlvLvError {
-    DataTooLarge(usize),
-    ByteConversion(ByteConversionError),
-    /// First value: Found value. Second value: Expected value if there is one.
-    InvalidTlvTypeField {
-        found: u8,
-        expected: Option<u8>,
-    },
-    /// Logically invalid value length detected. The value length may not exceed 255 bytes.
-    /// Depending on the concrete TLV type, the value length may also be logically invalid.
+    #[error("{0}")]
+    DataTooLarge(#[from] TlvLvDataTooLargeError),
+    #[error("byte conversion error: {0}")]
+    ByteConversion(#[from] ByteConversionError),
+    #[error("{0}")]
+    InvalidTlvTypeField(#[from] InvalidTlvTypeFieldError),
+    #[error("invalid value length {0}")]
     InvalidValueLength(usize),
     /// Only applies to filestore requests and responses. Second name was missing where one is
     /// expected.
+    #[error("second name missing for filestore request or response")]
     SecondNameMissing,
     /// Invalid action code for filestore requests or responses.
+    #[error("invalid action code {0}")]
     InvalidFilestoreActionCode(u8),
 }
 
-impl From<ByteConversionError> for TlvLvError {
-    fn from(value: ByteConversionError) -> Self {
-        Self::ByteConversion(value)
-    }
-}
-
-impl Display for TlvLvError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            TlvLvError::DataTooLarge(data_len) => {
-                write!(
-                    f,
-                    "data with size {} larger than allowed {} bytes",
-                    data_len,
-                    u8::MAX
-                )
-            }
-            TlvLvError::ByteConversion(e) => {
-                write!(f, "tlv or lv byte conversion: {}", e)
-            }
-            TlvLvError::InvalidTlvTypeField { found, expected } => {
-                write!(
-                    f,
-                    "invalid TLV type field, found {found}, expected {expected:?}"
-                )
-            }
-            TlvLvError::InvalidValueLength(len) => {
-                write!(f, "invalid value length {len}")
-            }
-            TlvLvError::SecondNameMissing => {
-                write!(f, "second name missing for filestore request or response")
-            }
-            TlvLvError::InvalidFilestoreActionCode(raw) => {
-                write!(f, "invalid filestore action code with raw value {raw}")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for TlvLvError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            TlvLvError::ByteConversion(e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/cfdp/pdu/ack.rs

@@ -10,6 +10,10 @@ use super::{
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
+#[error("invalid directive code of acknowledged PDU")]
+pub struct InvalidAckedDirectiveCodeError(pub FileDirectiveType);
+
 /// ACK PDU abstraction.
 ///
 /// For more information, refer to CFDP chapter 5.2.4.
@@ -29,16 +33,13 @@ impl AckPdu {
         directive_code_of_acked_pdu: FileDirectiveType,
         condition_code: ConditionCode,
         transaction_status: TransactionStatus,
-    ) -> Result<Self, PduError> {
+    ) -> Result<Self, InvalidAckedDirectiveCodeError> {
         if directive_code_of_acked_pdu == FileDirectiveType::EofPdu {
             pdu_header.pdu_conf.direction = Direction::TowardsSender;
         } else if directive_code_of_acked_pdu == FileDirectiveType::FinishedPdu {
             pdu_header.pdu_conf.direction = Direction::TowardsReceiver;
         } else {
-            return Err(PduError::InvalidDirectiveType {
-                found: directive_code_of_acked_pdu as u8,
-                expected: None,
-            });
+            return Err(InvalidAckedDirectiveCodeError(directive_code_of_acked_pdu));
         }
         // Force correct direction flag.
         let mut ack_pdu = Self {
@@ -81,22 +82,27 @@ impl AckPdu {
         .unwrap()
     }
 
+    #[inline]
     pub fn pdu_header(&self) -> &PduHeader {
         &self.pdu_header
     }
 
+    #[inline]
     pub fn directive_code_of_acked_pdu(&self) -> FileDirectiveType {
         self.directive_code_of_acked_pdu
     }
 
+    #[inline]
     pub fn condition_code(&self) -> ConditionCode {
         self.condition_code
     }
 
+    #[inline]
     pub fn transaction_status(&self) -> TransactionStatus {
         self.transaction_status
     }
 
+    #[inline]
     fn calc_pdu_datafield_len(&self) -> usize {
         if self.crc_flag() == CrcFlag::WithCrc {
             return 5;
@@ -140,27 +146,18 @@ impl AckPdu {
         let condition_code = ConditionCode::try_from((buf[current_idx] >> 4) & 0b1111)
             .map_err(|_| PduError::InvalidConditionCode((buf[current_idx] >> 4) & 0b1111))?;
         let transaction_status = TransactionStatus::try_from(buf[current_idx] & 0b11).unwrap();
-        Self::new(
+        // Unwrap okay, validity of acked directive code was checked.
+        Ok(Self::new(
             pdu_header,
             acked_directive_type,
             condition_code,
             transaction_status,
         )
-    }
-}
-
-impl CfdpPdu for AckPdu {
-    fn pdu_header(&self) -> &PduHeader {
-        &self.pdu_header
+        .unwrap())
     }
 
-    fn file_directive_type(&self) -> Option<FileDirectiveType> {
-        Some(FileDirectiveType::AckPdu)
-    }
-}
-
-impl WritablePduPacket for AckPdu {
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+    /// Write [Self] to the provided buffer and returns the written size.
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
         let expected_len = self.len_written();
         if buf.len() < expected_len {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -188,11 +185,33 @@ impl WritablePduPacket for AckPdu {
         Ok(current_idx)
     }
 
-    fn len_written(&self) -> usize {
+    pub fn len_written(&self) -> usize {
         self.pdu_header.header_len() + self.calc_pdu_datafield_len()
     }
 }
 
+impl CfdpPdu for AckPdu {
+    #[inline]
+    fn pdu_header(&self) -> &PduHeader {
+        self.pdu_header()
+    }
+
+    #[inline]
+    fn file_directive_type(&self) -> Option<FileDirectiveType> {
+        Some(FileDirectiveType::AckPdu)
+    }
+}
+
+impl WritablePduPacket for AckPdu {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+        self.write_to_bytes(buf)
+    }
+
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::cfdp::{
@@ -225,7 +244,7 @@ mod tests {
     #[test]
     fn test_basic() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let ack_pdu = AckPdu::new(
             pdu_header,
             FileDirectiveType::FinishedPdu,
@@ -245,7 +264,7 @@ mod tests {
         transaction_status: TransactionStatus,
     ) {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let ack_pdu = AckPdu::new_for_finished_pdu(pdu_header, condition_code, transaction_status);
         let mut buf: [u8; 64] = [0; 64];
         let res = ack_pdu.write_to_bytes(&mut buf);
@@ -267,15 +286,53 @@ mod tests {
         generic_serialization_test(ConditionCode::NoError, TransactionStatus::Active);
     }
 
+    #[test]
+    fn test_serialization_too_small() {
+        let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
+        let ack_pdu = AckPdu::new(
+            pdu_header,
+            FileDirectiveType::FinishedPdu,
+            ConditionCode::NoError,
+            TransactionStatus::Active,
+        )
+        .expect("creating ACK PDU failed");
+        if let Err(PduError::ByteConversion(ByteConversionError::ToSliceTooSmall {
+            found,
+            expected,
+        })) = ack_pdu.write_to_bytes(&mut [0; 5])
+        {
+            assert_eq!(found, 5);
+            assert_eq!(expected, ack_pdu.len_written());
+        } else {
+            panic!("serialization should have failed");
+        }
+    }
+
     #[test]
     fn test_serialization_fs_error() {
         generic_serialization_test(ConditionCode::FileSizeError, TransactionStatus::Terminated);
     }
+    #[test]
+    fn test_invalid_directive_code_of_acked_pdu() {
+        let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
+        assert_eq!(
+            AckPdu::new(
+                pdu_header,
+                FileDirectiveType::MetadataPdu,
+                ConditionCode::NoError,
+                TransactionStatus::Active,
+            )
+            .unwrap_err(),
+            InvalidAckedDirectiveCodeError(FileDirectiveType::MetadataPdu)
+        );
+    }
 
     #[test]
     fn test_deserialization() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let ack_pdu = AckPdu::new_for_finished_pdu(
             pdu_header,
             ConditionCode::NoError,
@@ -290,7 +347,7 @@ mod tests {
     #[test]
     fn test_with_crc() {
         let pdu_conf = common_pdu_conf(CrcFlag::WithCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let ack_pdu = AckPdu::new_for_finished_pdu(
             pdu_header,
             ConditionCode::NoError,
@@ -307,7 +364,7 @@ mod tests {
     #[test]
     fn test_for_eof_pdu() {
         let pdu_conf = common_pdu_conf(CrcFlag::WithCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let ack_pdu = AckPdu::new_for_eof_pdu(
             pdu_header,
             ConditionCode::NoError,
@@ -324,7 +381,7 @@ mod tests {
     #[cfg(feature = "serde")]
     fn test_ack_pdu_serialization() {
         let pdu_conf = common_pdu_conf(CrcFlag::WithCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let ack_pdu = AckPdu::new_for_eof_pdu(
             pdu_header,
             ConditionCode::NoError,

src/cfdp/pdu/eof.rs

@@ -25,32 +25,52 @@ pub struct EofPdu {
 }
 
 impl EofPdu {
-    pub fn new_no_error(mut pdu_header: PduHeader, file_checksum: u32, file_size: u64) -> Self {
+    pub fn new(
+        mut pdu_header: PduHeader,
+        condition_code: ConditionCode,
+        file_checksum: u32,
+        file_size: u64,
+        fault_location: Option<EntityIdTlv>,
+    ) -> Self {
         // Force correct direction flag.
         pdu_header.pdu_conf.direction = Direction::TowardsReceiver;
         let mut eof_pdu = Self {
             pdu_header,
-            condition_code: ConditionCode::NoError,
+            condition_code,
             file_checksum,
             file_size,
-            fault_location: None,
+            fault_location,
         };
         eof_pdu.pdu_header.pdu_datafield_len = eof_pdu.calc_pdu_datafield_len() as u16;
         eof_pdu
     }
 
+    pub fn new_no_error(pdu_header: PduHeader, file_checksum: u32, file_size: u64) -> Self {
+        Self::new(
+            pdu_header,
+            ConditionCode::NoError,
+            file_checksum,
+            file_size,
+            None,
+        )
+    }
+
+    #[inline]
     pub fn pdu_header(&self) -> &PduHeader {
         &self.pdu_header
     }
 
+    #[inline]
     pub fn condition_code(&self) -> ConditionCode {
         self.condition_code
     }
 
+    #[inline]
     pub fn file_checksum(&self) -> u32 {
         self.file_checksum
     }
 
+    #[inline]
     pub fn file_size(&self) -> u64 {
         self.file_size
     }
@@ -113,20 +133,9 @@ impl EofPdu {
             fault_location,
         })
     }
-}
 
-impl CfdpPdu for EofPdu {
-    fn pdu_header(&self) -> &PduHeader {
-        &self.pdu_header
-    }
-
-    fn file_directive_type(&self) -> Option<FileDirectiveType> {
-        Some(FileDirectiveType::EofPdu)
-    }
-}
-
-impl WritablePduPacket for EofPdu {
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+    /// Write [Self] to the provided buffer and returns the written size.
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
         let expected_len = self.len_written();
         if buf.len() < expected_len {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -148,7 +157,7 @@ impl WritablePduPacket for EofPdu {
             &mut buf[current_idx..],
         )?;
         if let Some(fault_location) = self.fault_location {
-            current_idx += fault_location.write_to_bytes(buf)?;
+            current_idx += fault_location.write_to_bytes(&mut buf[current_idx..])?;
         }
         if self.crc_flag() == CrcFlag::WithCrc {
             current_idx = add_pdu_crc(buf, current_idx);
@@ -156,11 +165,33 @@ impl WritablePduPacket for EofPdu {
         Ok(current_idx)
     }
 
-    fn len_written(&self) -> usize {
+    pub fn len_written(&self) -> usize {
         self.pdu_header.header_len() + self.calc_pdu_datafield_len()
     }
 }
 
+impl CfdpPdu for EofPdu {
+    #[inline]
+    fn pdu_header(&self) -> &PduHeader {
+        self.pdu_header()
+    }
+
+    #[inline]
+    fn file_directive_type(&self) -> Option<FileDirectiveType> {
+        Some(FileDirectiveType::EofPdu)
+    }
+}
+
+impl WritablePduPacket for EofPdu {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+        self.write_to_bytes(buf)
+    }
+
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -171,13 +202,23 @@ mod tests {
     use crate::cfdp::{ConditionCode, CrcFlag, LargeFileFlag, PduType, TransmissionMode};
     #[cfg(feature = "serde")]
     use crate::tests::generic_serde_test;
+    use crate::util::{UnsignedByteFieldU16, UnsignedEnum};
 
-    fn verify_state(&eof_pdu: &EofPdu, file_flag: LargeFileFlag) {
+    fn verify_state_no_error_no_crc(eof_pdu: &EofPdu, file_flag: LargeFileFlag) {
+        verify_state(eof_pdu, CrcFlag::NoCrc, file_flag, ConditionCode::NoError);
+    }
+
+    fn verify_state(
+        eof_pdu: &EofPdu,
+        crc_flag: CrcFlag,
+        file_flag: LargeFileFlag,
+        cond_code: ConditionCode,
+    ) {
         assert_eq!(eof_pdu.file_checksum(), 0x01020304);
         assert_eq!(eof_pdu.file_size(), 12);
-        assert_eq!(eof_pdu.condition_code(), ConditionCode::NoError);
+        assert_eq!(eof_pdu.condition_code(), cond_code);
 
-        assert_eq!(eof_pdu.crc_flag(), CrcFlag::NoCrc);
+        assert_eq!(eof_pdu.crc_flag(), crc_flag);
         assert_eq!(eof_pdu.file_flag(), file_flag);
         assert_eq!(eof_pdu.pdu_type(), PduType::FileDirective);
         assert_eq!(
@@ -194,16 +235,16 @@ mod tests {
     #[test]
     fn test_basic() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
         assert_eq!(eof_pdu.len_written(), pdu_header.header_len() + 2 + 4 + 4);
-        verify_state(&eof_pdu, LargeFileFlag::Normal);
+        verify_state_no_error_no_crc(&eof_pdu, LargeFileFlag::Normal);
     }
 
     #[test]
     fn test_serialization() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
         let mut buf: [u8; 64] = [0; 64];
         let res = eof_pdu.write_to_bytes(&mut buf);
@@ -235,7 +276,7 @@ mod tests {
     #[test]
     fn test_deserialization() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
         let mut buf: [u8; 64] = [0; 64];
         eof_pdu.write_to_bytes(&mut buf).unwrap();
@@ -250,7 +291,7 @@ mod tests {
     #[test]
     fn test_write_to_vec() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
         let mut buf: [u8; 64] = [0; 64];
         let written = eof_pdu.write_to_bytes(&mut buf).unwrap();
@@ -261,7 +302,7 @@ mod tests {
     #[test]
     fn test_with_crc() {
         let pdu_conf = common_pdu_conf(CrcFlag::WithCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
         let mut buf: [u8; 64] = [0; 64];
         let written = eof_pdu.write_to_bytes(&mut buf).unwrap();
@@ -271,7 +312,7 @@ mod tests {
         buf[written - 1] -= 1;
         let crc: u16 = ((buf[written - 2] as u16) << 8) as u16 | buf[written - 1] as u16;
         let error = EofPdu::from_bytes(&buf).unwrap_err();
-        if let PduError::ChecksumError(e) = error {
+        if let PduError::Checksum(e) = error {
             assert_eq!(e, crc);
         } else {
             panic!("expected crc error");
@@ -281,9 +322,9 @@ mod tests {
     #[test]
     fn test_with_large_file_flag() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Large);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
-        verify_state(&eof_pdu, LargeFileFlag::Large);
+        verify_state_no_error_no_crc(&eof_pdu, LargeFileFlag::Large);
         assert_eq!(eof_pdu.len_written(), pdu_header.header_len() + 2 + 8 + 4);
     }
 
@@ -291,8 +332,52 @@ mod tests {
     #[cfg(feature = "serde")]
     fn test_eof_serde() {
         let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal);
-        let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
         let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
         generic_serde_test(eof_pdu);
     }
+
+    fn generic_test_with_fault_location_and_error(crc: CrcFlag) {
+        let pdu_conf = common_pdu_conf(crc, LargeFileFlag::Normal);
+        let pdu_header = PduHeader::new_for_file_directive(pdu_conf, 0);
+        let eof_pdu = EofPdu::new(
+            pdu_header,
+            ConditionCode::FileChecksumFailure,
+            0x01020304,
+            12,
+            Some(EntityIdTlv::new(UnsignedByteFieldU16::new(5).into())),
+        );
+        let mut expected_len = pdu_header.header_len() + 2 + 4 + 4 + 4;
+        if crc == CrcFlag::WithCrc {
+            expected_len += 2;
+        }
+        // Entity ID TLV increaes length by 4.
+        assert_eq!(eof_pdu.len_written(), expected_len);
+        verify_state(
+            &eof_pdu,
+            crc,
+            LargeFileFlag::Normal,
+            ConditionCode::FileChecksumFailure,
+        );
+        let eof_vec = eof_pdu.to_vec().unwrap();
+        let eof_read_back = EofPdu::from_bytes(&eof_vec);
+        if let Err(e) = eof_read_back {
+            panic!("deserialization failed with: {e}")
+        }
+        let eof_read_back = eof_read_back.unwrap();
+        assert_eq!(eof_read_back, eof_pdu);
+        assert!(eof_read_back.fault_location.is_some());
+        assert_eq!(eof_read_back.fault_location.unwrap().entity_id().value(), 5);
+        assert_eq!(eof_read_back.fault_location.unwrap().entity_id().size(), 2);
+    }
+
+    #[test]
+    fn test_with_fault_location_and_error() {
+        generic_test_with_fault_location_and_error(CrcFlag::NoCrc);
+    }
+
+    #[test]
+    fn test_with_fault_location_and_error_and_crc() {
+        generic_test_with_fault_location_and_error(CrcFlag::WithCrc);
+    }
 }

src/cfdp/pdu/file_data.rs

@@ -10,8 +10,10 @@ use serde::{Deserialize, Serialize};
 
 use super::{CfdpPdu, FileDirectiveType, WritablePduPacket};
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
+#[derive(Debug, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u2, exhaustive = true)]
 #[repr(u8)]
 pub enum RecordContinuationState {
     NoStartNoEnd = 0b00,
@@ -43,24 +45,27 @@ impl<'seg_meta> SegmentMetadata<'seg_meta> {
         })
     }
 
+    #[inline]
     pub fn record_continuation_state(&self) -> RecordContinuationState {
         self.record_continuation_state
     }
 
+    #[inline]
     pub fn metadata(&self) -> Option<&'seg_meta [u8]> {
         self.metadata
     }
 
-    pub fn written_len(&self) -> usize {
+    #[inline]
+    pub fn len_written(&self) -> usize {
         // Map empty metadata to 0 and slice to its length.
         1 + self.metadata.map_or(0, |meta| meta.len())
     }
 
     pub(crate) fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
-        if buf.len() < self.written_len() {
+        if buf.len() < self.len_written() {
             return Err(ByteConversionError::ToSliceTooSmall {
                 found: buf.len(),
-                expected: self.written_len(),
+                expected: self.len_written(),
             });
         }
         buf[0] = ((self.record_continuation_state as u8) << 6)
@@ -68,7 +73,7 @@ impl<'seg_meta> SegmentMetadata<'seg_meta> {
         if let Some(metadata) = self.metadata {
             buf[1..1 + metadata.len()].copy_from_slice(metadata)
         }
-        Ok(self.written_len())
+        Ok(self.len_written())
     }
 
     pub(crate) fn from_bytes(buf: &'seg_meta [u8]) -> Result<Self, ByteConversionError> {
@@ -92,16 +97,74 @@ impl<'seg_meta> SegmentMetadata<'seg_meta> {
     }
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+struct FdPduBase<'seg_meta> {
+    pdu_header: PduHeader,
+    #[cfg_attr(feature = "serde", serde(borrow))]
+    segment_metadata: Option<SegmentMetadata<'seg_meta>>,
+    offset: u64,
+}
+
+impl CfdpPdu for FdPduBase<'_> {
+    #[inline]
+    fn pdu_header(&self) -> &PduHeader {
+        self.pdu_header()
+    }
+
+    #[inline]
+    fn file_directive_type(&self) -> Option<FileDirectiveType> {
+        None
+    }
+}
+
+impl FdPduBase<'_> {
+    fn calc_pdu_datafield_len(&self, file_data_len: u64) -> usize {
+        let mut len = core::mem::size_of::<u32>();
+        if self.pdu_header.pdu_conf.file_flag == LargeFileFlag::Large {
+            len += 4;
+        }
+        if self.segment_metadata.is_some() {
+            len += self.segment_metadata.as_ref().unwrap().len_written()
+        }
+        len += file_data_len as usize;
+        if self.crc_flag() == CrcFlag::WithCrc {
+            len += 2;
+        }
+        len
+    }
+
+    fn write_common_fields_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+        let mut current_idx = self.pdu_header.write_to_bytes(buf)?;
+        if self.segment_metadata.is_some() {
+            current_idx += self
+                .segment_metadata
+                .as_ref()
+                .unwrap()
+                .write_to_bytes(&mut buf[current_idx..])?;
+        }
+        current_idx += write_fss_field(
+            self.pdu_header.common_pdu_conf().file_flag,
+            self.offset,
+            &mut buf[current_idx..],
+        )?;
+        Ok(current_idx)
+    }
+
+    #[inline]
+    pub fn pdu_header(&self) -> &PduHeader {
+        &self.pdu_header
+    }
+}
+
 /// File Data PDU abstraction.
 ///
 /// For more information, refer to CFDP chapter 5.3.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct FileDataPdu<'seg_meta, 'file_data> {
-    pdu_header: PduHeader,
     #[cfg_attr(feature = "serde", serde(borrow))]
-    segment_metadata: Option<SegmentMetadata<'seg_meta>>,
-    offset: u64,
+    common: FdPduBase<'seg_meta>,
     file_data: &'file_data [u8],
 }
 
@@ -134,42 +197,42 @@ impl<'seg_meta, 'file_data> FileDataPdu<'seg_meta, 'file_data> {
             pdu_header.seg_metadata_flag = SegmentMetadataFlag::Present;
         }
         let mut pdu = Self {
+            common: FdPduBase {
                 pdu_header,
                 segment_metadata,
                 offset,
+            },
             file_data,
         };
-        pdu.pdu_header.pdu_datafield_len = pdu.calc_pdu_datafield_len() as u16;
+        pdu.common.pdu_header.pdu_datafield_len = pdu.calc_pdu_datafield_len() as u16;
         pdu
     }
 
     fn calc_pdu_datafield_len(&self) -> usize {
-        let mut len = core::mem::size_of::<u32>();
-        if self.pdu_header.pdu_conf.file_flag == LargeFileFlag::Large {
-            len += 4;
-        }
-        if self.segment_metadata.is_some() {
-            len += self.segment_metadata.as_ref().unwrap().written_len()
-        }
-        len += self.file_data.len();
-        if self.crc_flag() == CrcFlag::WithCrc {
-            len += 2;
-        }
-        len
+        self.common
+            .calc_pdu_datafield_len(self.file_data.len() as u64)
     }
 
+    #[inline]
+    pub fn segment_metadata(&self) -> Option<&SegmentMetadata<'_>> {
+        self.common.segment_metadata.as_ref()
+    }
+
+    #[inline]
+    pub fn pdu_header(&self) -> &PduHeader {
+        self.common.pdu_header()
+    }
+
+    #[inline]
     pub fn offset(&self) -> u64 {
-        self.offset
+        self.common.offset
     }
 
+    #[inline]
     pub fn file_data(&self) -> &'file_data [u8] {
         self.file_data
     }
 
-    pub fn segment_metadata(&self) -> Option<&SegmentMetadata> {
-        self.segment_metadata.as_ref()
-    }
-
     pub fn from_bytes<'buf: 'seg_meta + 'file_data>(buf: &'buf [u8]) -> Result<Self, PduError> {
         let (pdu_header, mut current_idx) = PduHeader::from_bytes(buf)?;
         let full_len_without_crc = pdu_header.verify_length_and_checksum(buf)?;
@@ -178,7 +241,7 @@ impl<'seg_meta, 'file_data> FileDataPdu<'seg_meta, 'file_data> {
         let mut segment_metadata = None;
         if pdu_header.seg_metadata_flag == SegmentMetadataFlag::Present {
             segment_metadata = Some(SegmentMetadata::from_bytes(&buf[current_idx..])?);
-            current_idx += segment_metadata.as_ref().unwrap().written_len();
+            current_idx += segment_metadata.as_ref().unwrap().len_written();
         }
         let (fss, offset) = read_fss_field(pdu_header.pdu_conf.file_flag, &buf[current_idx..]);
         current_idx += fss;
@@ -190,25 +253,17 @@ impl<'seg_meta, 'file_data> FileDataPdu<'seg_meta, 'file_data> {
             .into());
         }
         Ok(Self {
+            common: FdPduBase {
                 pdu_header,
                 segment_metadata,
                 offset,
+            },
             file_data: &buf[current_idx..full_len_without_crc],
         })
     }
-}
-impl CfdpPdu for FileDataPdu<'_, '_> {
-    fn pdu_header(&self) -> &PduHeader {
-        &self.pdu_header
-    }
 
-    fn file_directive_type(&self) -> Option<FileDirectiveType> {
-        None
-    }
-}
-
-impl WritablePduPacket for FileDataPdu<'_, '_> {
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+    /// Write [Self] to the provided buffer and returns the written size.
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
         if buf.len() < self.len_written() {
             return Err(ByteConversionError::ToSliceTooSmall {
                 found: buf.len(),
@@ -216,19 +271,8 @@ impl WritablePduPacket for FileDataPdu<'_, '_> {
             }
             .into());
         }
-        let mut current_idx = self.pdu_header.write_to_bytes(buf)?;
-        if self.segment_metadata.is_some() {
-            current_idx += self
-                .segment_metadata
-                .as_ref()
-                .unwrap()
-                .write_to_bytes(&mut buf[current_idx..])?;
-        }
-        current_idx += write_fss_field(
-            self.pdu_header.common_pdu_conf().file_flag,
-            self.offset,
-            &mut buf[current_idx..],
-        )?;
+
+        let mut current_idx = self.common.write_common_fields_to_bytes(buf)?;
         buf[current_idx..current_idx + self.file_data.len()].copy_from_slice(self.file_data);
         current_idx += self.file_data.len();
         if self.crc_flag() == CrcFlag::WithCrc {
@@ -237,10 +281,188 @@ impl WritablePduPacket for FileDataPdu<'_, '_> {
         Ok(current_idx)
     }
 
-    fn len_written(&self) -> usize {
-        self.pdu_header.header_len() + self.calc_pdu_datafield_len()
+    pub fn len_written(&self) -> usize {
+        self.common.pdu_header.header_len() + self.calc_pdu_datafield_len()
     }
 }
+impl CfdpPdu for FileDataPdu<'_, '_> {
+    #[inline]
+    fn pdu_header(&self) -> &PduHeader {
+        &self.common.pdu_header
+    }
+
+    #[inline]
+    fn file_directive_type(&self) -> Option<FileDirectiveType> {
+        None
+    }
+}
+
+impl WritablePduPacket for FileDataPdu<'_, '_> {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+        self.write_to_bytes(buf)
+    }
+
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
+/// File Data PDU creator abstraction.
+///
+/// This special creator object allows to read into the file data buffer directly. This avoids
+/// the need of an additional buffer to create a file data PDU. This structure therefore
+/// does not implement the regular [WritablePduPacket] trait.
+///
+/// For more information, refer to CFDP chapter 5.3.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct FileDataPduCreatorWithReservedDatafield<'seg_meta> {
+    #[cfg_attr(feature = "serde", serde(borrow))]
+    common: FdPduBase<'seg_meta>,
+    file_data_len: u64,
+}
+
+impl<'seg_meta> FileDataPduCreatorWithReservedDatafield<'seg_meta> {
+    pub fn new_with_seg_metadata(
+        pdu_header: PduHeader,
+        segment_metadata: SegmentMetadata<'seg_meta>,
+        offset: u64,
+        file_data_len: u64,
+    ) -> Self {
+        Self::new_generic(pdu_header, Some(segment_metadata), offset, file_data_len)
+    }
+
+    pub fn new_no_seg_metadata(pdu_header: PduHeader, offset: u64, file_data_len: u64) -> Self {
+        Self::new_generic(pdu_header, None, offset, file_data_len)
+    }
+
+    pub fn new_generic(
+        mut pdu_header: PduHeader,
+        segment_metadata: Option<SegmentMetadata<'seg_meta>>,
+        offset: u64,
+        file_data_len: u64,
+    ) -> Self {
+        pdu_header.pdu_type = PduType::FileData;
+        if segment_metadata.is_some() {
+            pdu_header.seg_metadata_flag = SegmentMetadataFlag::Present;
+        }
+        let mut pdu = Self {
+            common: FdPduBase {
+                pdu_header,
+                segment_metadata,
+                offset,
+            },
+            file_data_len,
+        };
+        pdu.common.pdu_header.pdu_datafield_len = pdu.calc_pdu_datafield_len() as u16;
+        pdu
+    }
+
+    fn calc_pdu_datafield_len(&self) -> usize {
+        self.common.calc_pdu_datafield_len(self.file_data_len)
+    }
+
+    pub fn len_written(&self) -> usize {
+        self.common.pdu_header.header_len() + self.calc_pdu_datafield_len()
+    }
+
+    /// This function performs a partial write by writing all data except the file data
+    /// and the CRC.
+    ///
+    /// It returns a [FileDataPduCreatorWithUnwrittenData] which provides a mutable slice to
+    /// the reserved file data field. The user can read file data into this field directly and
+    /// then finish the PDU creation using the [FileDataPduCreatorWithUnwrittenData::finish] call.
+    pub fn write_to_bytes_partially<'buf>(
+        &self,
+        buf: &'buf mut [u8],
+    ) -> Result<FileDataPduCreatorWithUnwrittenData<'buf>, PduError> {
+        if buf.len() < self.len_written() {
+            return Err(ByteConversionError::ToSliceTooSmall {
+                found: buf.len(),
+                expected: self.len_written(),
+            }
+            .into());
+        }
+        let mut current_idx = self.common.write_common_fields_to_bytes(buf)?;
+        let file_data_offset = current_idx as u64;
+        current_idx += self.file_data_len as usize;
+        if self.crc_flag() == CrcFlag::WithCrc {
+            current_idx += 2;
+        }
+        Ok(FileDataPduCreatorWithUnwrittenData {
+            write_buf: &mut buf[0..current_idx],
+            file_data_offset,
+            file_data_len: self.file_data_len,
+            needs_crc: self.crc_flag() == CrcFlag::WithCrc,
+        })
+    }
+}
+
+impl CfdpPdu for FileDataPduCreatorWithReservedDatafield<'_> {
+    fn pdu_header(&self) -> &PduHeader {
+        &self.common.pdu_header
+    }
+
+    fn file_directive_type(&self) -> Option<FileDirectiveType> {
+        None
+    }
+}
+
+/// This structure is created with [FileDataPduCreatorWithReservedDatafield::write_to_bytes_partially]
+/// and provides an API to read file data from the virtual filesystem into the file data PDU buffer
+/// directly.
+///
+/// This structure provides a mutable slice to the reserved file data field. The user can read
+/// file data into this field directly and then finish the PDU creation using the
+/// [FileDataPduCreatorWithUnwrittenData::finish] call.
+pub struct FileDataPduCreatorWithUnwrittenData<'buf> {
+    write_buf: &'buf mut [u8],
+    file_data_offset: u64,
+    file_data_len: u64,
+    needs_crc: bool,
+}
+
+impl FileDataPduCreatorWithUnwrittenData<'_> {
+    pub fn file_data_field_mut(&mut self) -> &mut [u8] {
+        &mut self.write_buf[self.file_data_offset as usize
+            ..self.file_data_offset as usize + self.file_data_len as usize]
+    }
+
+    /// This functio needs to be called to add a CRC to the file data PDU where applicable.
+    ///
+    /// It returns the full written size of the PDU.
+    pub fn finish(self) -> usize {
+        if self.needs_crc {
+            add_pdu_crc(
+                self.write_buf,
+                self.file_data_offset as usize + self.file_data_len as usize,
+            );
+        }
+        self.write_buf.len()
+    }
+}
+
+/// This function can be used to calculate the maximum allowed file segment size for
+/// a given maximum packet length and the segment metadata if there is any.
+pub fn calculate_max_file_seg_len_for_max_packet_len_and_pdu_header(
+    pdu_header: &PduHeader,
+    max_packet_len: usize,
+    segment_metadata: Option<&SegmentMetadata>,
+) -> usize {
+    let mut subtract = pdu_header.header_len();
+    if let Some(segment_metadata) = segment_metadata {
+        subtract += 1 + segment_metadata.metadata().unwrap().len();
+    }
+    if pdu_header.common_pdu_conf().file_flag == LargeFileFlag::Large {
+        subtract += 8;
+    } else {
+        subtract += 4;
+    }
+    if pdu_header.common_pdu_conf().crc_flag == CrcFlag::WithCrc {
+        subtract += 2;
+    }
+    max_packet_len.saturating_sub(subtract)
+}
 
 #[cfg(test)]
 mod tests {
@@ -263,7 +485,7 @@ mod tests {
         assert!(fd_pdu.segment_metadata().is_none());
         assert_eq!(
             fd_pdu.len_written(),
-            fd_pdu.pdu_header.header_len() + core::mem::size_of::<u32>() + 4
+            fd_pdu.pdu_header().header_len() + core::mem::size_of::<u32>() + 4
         );
 
         assert_eq!(fd_pdu.crc_flag(), CrcFlag::NoCrc);
@@ -290,11 +512,11 @@ mod tests {
         let written = res.unwrap();
         assert_eq!(
             written,
-            fd_pdu.pdu_header.header_len() + core::mem::size_of::<u32>() + 4
+            fd_pdu.pdu_header().header_len() + core::mem::size_of::<u32>() + 4
         );
-        let mut current_idx = fd_pdu.pdu_header.header_len();
+        let mut current_idx = fd_pdu.pdu_header().header_len();
         let file_size = u32::from_be_bytes(
-            buf[fd_pdu.pdu_header.header_len()..fd_pdu.pdu_header.header_len() + 4]
+            buf[fd_pdu.pdu_header().header_len()..fd_pdu.pdu_header().header_len() + 4]
                 .try_into()
                 .unwrap(),
         );
@@ -353,7 +575,7 @@ mod tests {
         buf[written - 1] -= 1;
         let crc: u16 = ((buf[written - 2] as u16) << 8) | buf[written - 1] as u16;
         let error = FileDataPdu::from_bytes(&buf).unwrap_err();
-        if let PduError::ChecksumError(e) = error {
+        if let PduError::Checksum(e) = error {
             assert_eq!(e, crc);
         } else {
             panic!("expected crc error");
@@ -380,7 +602,7 @@ mod tests {
         assert_eq!(*fd_pdu.segment_metadata().unwrap(), segment_meta);
         assert_eq!(
             fd_pdu.len_written(),
-            fd_pdu.pdu_header.header_len()
+            fd_pdu.pdu_header().header_len()
                 + 1
                 + seg_metadata.len()
                 + core::mem::size_of::<u32>()
@@ -390,7 +612,7 @@ mod tests {
         fd_pdu
             .write_to_bytes(&mut buf)
             .expect("writing FD PDU failed");
-        let mut current_idx = fd_pdu.pdu_header.header_len();
+        let mut current_idx = fd_pdu.pdu_header().header_len();
         assert_eq!(
             RecordContinuationState::try_from((buf[current_idx] >> 6) & 0b11).unwrap(),
             RecordContinuationState::StartAndEnd
@@ -482,4 +704,142 @@ mod tests {
         let output_converted_back: FileDataPdu = from_bytes(&output).unwrap();
         assert_eq!(output_converted_back, fd_pdu);
     }
+
+    #[test]
+    fn test_fd_pdu_creator_with_reserved_field_no_crc() {
+        let common_conf =
+            CommonPduConfig::new_with_byte_fields(TEST_SRC_ID, TEST_DEST_ID, TEST_SEQ_NUM).unwrap();
+        let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
+        let test_str = "hello world!";
+        let fd_pdu = FileDataPduCreatorWithReservedDatafield::new_no_seg_metadata(
+            pdu_header,
+            10,
+            test_str.len() as u64,
+        );
+        let mut write_buf: [u8; 64] = [0; 64];
+        let mut pdu_unwritten = fd_pdu
+            .write_to_bytes_partially(&mut write_buf)
+            .expect("partial write failed");
+        pdu_unwritten
+            .file_data_field_mut()
+            .copy_from_slice(test_str.as_bytes());
+        pdu_unwritten.finish();
+
+        let pdu_reader = FileDataPdu::from_bytes(&write_buf).expect("reading file data PDU failed");
+        assert_eq!(
+            core::str::from_utf8(pdu_reader.file_data()).expect("reading utf8 string failed"),
+            "hello world!"
+        );
+    }
+
+    #[test]
+    fn test_fd_pdu_creator_with_reserved_field_with_crc() {
+        let mut common_conf =
+            CommonPduConfig::new_with_byte_fields(TEST_SRC_ID, TEST_DEST_ID, TEST_SEQ_NUM).unwrap();
+        common_conf.crc_flag = true.into();
+        let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
+        let test_str = "hello world!";
+        let fd_pdu = FileDataPduCreatorWithReservedDatafield::new_no_seg_metadata(
+            pdu_header,
+            10,
+            test_str.len() as u64,
+        );
+        let mut write_buf: [u8; 64] = [0; 64];
+        let mut pdu_unwritten = fd_pdu
+            .write_to_bytes_partially(&mut write_buf)
+            .expect("partial write failed");
+        pdu_unwritten
+            .file_data_field_mut()
+            .copy_from_slice(test_str.as_bytes());
+        pdu_unwritten.finish();
+
+        let pdu_reader = FileDataPdu::from_bytes(&write_buf).expect("reading file data PDU failed");
+        assert_eq!(
+            core::str::from_utf8(pdu_reader.file_data()).expect("reading utf8 string failed"),
+            "hello world!"
+        );
+    }
+
+    #[test]
+    fn test_fd_pdu_creator_with_reserved_field_with_crc_without_finish_fails() {
+        let mut common_conf =
+            CommonPduConfig::new_with_byte_fields(TEST_SRC_ID, TEST_DEST_ID, TEST_SEQ_NUM).unwrap();
+        common_conf.crc_flag = true.into();
+        let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
+        let test_str = "hello world!";
+        let fd_pdu = FileDataPduCreatorWithReservedDatafield::new_no_seg_metadata(
+            pdu_header,
+            10,
+            test_str.len() as u64,
+        );
+        let mut write_buf: [u8; 64] = [0; 64];
+        let mut pdu_unwritten = fd_pdu
+            .write_to_bytes_partially(&mut write_buf)
+            .expect("partial write failed");
+        pdu_unwritten
+            .file_data_field_mut()
+            .copy_from_slice(test_str.as_bytes());
+
+        let pdu_reader_error = FileDataPdu::from_bytes(&write_buf);
+        assert!(pdu_reader_error.is_err());
+        let error = pdu_reader_error.unwrap_err();
+        match error {
+            PduError::Checksum(_) => (),
+            _ => {
+                panic!("unexpected PDU error {}", error)
+            }
+        }
+    }
+
+    #[test]
+    fn test_max_file_seg_calculator_0() {
+        let pdu_header = PduHeader::new_for_file_data_default(CommonPduConfig::default(), 0);
+        assert_eq!(
+            calculate_max_file_seg_len_for_max_packet_len_and_pdu_header(&pdu_header, 64, None),
+            53
+        );
+    }
+
+    #[test]
+    fn test_max_file_seg_calculator_1() {
+        let common_conf = CommonPduConfig {
+            crc_flag: CrcFlag::WithCrc,
+            ..Default::default()
+        };
+        let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
+        assert_eq!(
+            calculate_max_file_seg_len_for_max_packet_len_and_pdu_header(&pdu_header, 64, None),
+            51
+        );
+    }
+
+    #[test]
+    fn test_max_file_seg_calculator_2() {
+        let common_conf = CommonPduConfig {
+            file_flag: LargeFileFlag::Large,
+            ..Default::default()
+        };
+        let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
+        assert_eq!(
+            calculate_max_file_seg_len_for_max_packet_len_and_pdu_header(&pdu_header, 64, None),
+            49
+        );
+    }
+
+    #[test]
+    fn test_max_file_seg_calculator_saturating_sub() {
+        let common_conf = CommonPduConfig {
+            file_flag: LargeFileFlag::Large,
+            ..Default::default()
+        };
+        let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
+        assert_eq!(
+            calculate_max_file_seg_len_for_max_packet_len_and_pdu_header(&pdu_header, 15, None),
+            0
+        );
+        assert_eq!(
+            calculate_max_file_seg_len_for_max_packet_len_and_pdu_header(&pdu_header, 14, None),
+            0
+        );
+    }
 }

src/cfdp/pdu/finished.rs

@@ -4,13 +4,14 @@ use crate::cfdp::pdu::{
 use crate::cfdp::tlv::{
     EntityIdTlv, FilestoreResponseTlv, GenericTlv, Tlv, TlvType, TlvTypeField, WritableTlv,
 };
-use crate::cfdp::{ConditionCode, CrcFlag, Direction, PduType, TlvLvError};
+use crate::cfdp::{ConditionCode, CrcFlag, Direction, PduType};
 use crate::ByteConversionError;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use super::{CfdpPdu, WritablePduPacket};
+use super::tlv::ReadableTlv;
+use super::{CfdpPdu, InvalidTlvTypeFieldError, WritablePduPacket};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -49,12 +50,12 @@ pub struct FinishedPduCreator<'fs_responses> {
 
 impl<'fs_responses> FinishedPduCreator<'fs_responses> {
     /// Default finished PDU: No error (no fault location field) and no filestore responses.
-    pub fn new_default(
+    pub fn new_no_error(
         pdu_header: PduHeader,
         delivery_code: DeliveryCode,
         file_status: FileStatus,
     ) -> Self {
-        Self::new_generic(
+        Self::new(
             pdu_header,
             ConditionCode::NoError,
             delivery_code,
@@ -71,7 +72,7 @@ impl<'fs_responses> FinishedPduCreator<'fs_responses> {
         file_status: FileStatus,
         fault_location: EntityIdTlv,
     ) -> Self {
-        Self::new_generic(
+        Self::new(
             pdu_header,
             condition_code,
             delivery_code,
@@ -81,7 +82,7 @@ impl<'fs_responses> FinishedPduCreator<'fs_responses> {
         )
     }
 
-    pub fn new_generic(
+    pub fn new(
         mut pdu_header: PduHeader,
         condition_code: ConditionCode,
         delivery_code: DeliveryCode,
@@ -108,23 +109,33 @@ impl<'fs_responses> FinishedPduCreator<'fs_responses> {
         finished_pdu
     }
 
+    #[inline]
+    pub fn pdu_header(&self) -> &PduHeader {
+        &self.pdu_header
+    }
+
+    #[inline]
     pub fn condition_code(&self) -> ConditionCode {
         self.condition_code
     }
 
+    #[inline]
     pub fn delivery_code(&self) -> DeliveryCode {
         self.delivery_code
     }
 
+    #[inline]
     pub fn file_status(&self) -> FileStatus {
         self.file_status
     }
 
     // If there are no filestore responses, an empty slice will be returned.
+    #[inline]
     pub fn filestore_responses(&self) -> &[FilestoreResponseTlv<'_, '_, '_>] {
         self.fs_responses
     }
 
+    #[inline]
     pub fn fault_location(&self) -> Option<EntityIdTlv> {
         self.fault_location
     }
@@ -142,20 +153,9 @@ impl<'fs_responses> FinishedPduCreator<'fs_responses> {
         }
         datafield_len
     }
-}
 
-impl CfdpPdu for FinishedPduCreator<'_> {
-    fn pdu_header(&self) -> &PduHeader {
-        &self.pdu_header
-    }
-
-    fn file_directive_type(&self) -> Option<FileDirectiveType> {
-        Some(FileDirectiveType::FinishedPdu)
-    }
-}
-
-impl WritablePduPacket for FinishedPduCreator<'_> {
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+    /// Write [Self] to the provided buffer and returns the written size.
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
         let expected_len = self.len_written();
         if buf.len() < expected_len {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -184,11 +184,33 @@ impl WritablePduPacket for FinishedPduCreator<'_> {
         Ok(current_idx)
     }
 
-    fn len_written(&self) -> usize {
+    pub fn len_written(&self) -> usize {
         self.pdu_header.header_len() + self.calc_pdu_datafield_len()
     }
 }
 
+impl CfdpPdu for FinishedPduCreator<'_> {
+    #[inline]
+    fn pdu_header(&self) -> &PduHeader {
+        self.pdu_header()
+    }
+
+    #[inline]
+    fn file_directive_type(&self) -> Option<FileDirectiveType> {
+        Some(FileDirectiveType::FinishedPdu)
+    }
+}
+
+impl WritablePduPacket for FinishedPduCreator<'_> {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+        self.write_to_bytes(buf)
+    }
+
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
 /// Helper structure to loop through all filestore responses of a read Finished PDU. It should be
 /// noted that iterators in Rust are not fallible, but the TLV creation can fail, for example if
 /// the raw TLV data is invalid for some reason. In that case, the iterator will yield [None]
@@ -275,10 +297,12 @@ impl<'buf> FinishedPduReader<'buf> {
         })
     }
 
+    #[inline]
     pub fn fs_responses_raw(&self) -> &[u8] {
         self.fs_responses_raw
     }
 
+    #[inline]
     pub fn fs_responses_iter(&self) -> FilestoreResponseIterator<'_> {
         FilestoreResponseIterator {
             responses_buf: self.fs_responses_raw,
@@ -286,22 +310,31 @@ impl<'buf> FinishedPduReader<'buf> {
         }
     }
 
+    #[inline]
     pub fn condition_code(&self) -> ConditionCode {
         self.condition_code
     }
 
+    #[inline]
     pub fn delivery_code(&self) -> DeliveryCode {
         self.delivery_code
     }
 
+    #[inline]
     pub fn file_status(&self) -> FileStatus {
         self.file_status
     }
 
+    #[inline]
     pub fn fault_location(&self) -> Option<EntityIdTlv> {
         self.fault_location
     }
 
+    #[inline]
+    pub fn pdu_header(&self) -> &PduHeader {
+        &self.pdu_header
+    }
+
     fn parse_tlv_fields(
         mut current_idx: usize,
         full_len_without_crc: usize,
@@ -331,22 +364,26 @@ impl<'buf> FinishedPduReader<'buf> {
                         // last TLV, everything else would break the whole handling of the packet
                         // TLVs.
                         if current_idx != full_len_without_crc {
-                            return Err(PduError::FormatError);
+                            return Err(PduError::Format);
                         }
                     } else {
-                        return Err(TlvLvError::InvalidTlvTypeField {
+                        return Err(PduError::TlvLv(
+                            InvalidTlvTypeFieldError {
                                 found: tlv_type.into(),
                                 expected: Some(TlvType::FilestoreResponse.into()),
                             }
-                        .into());
+                            .into(),
+                        ));
                     }
                 }
                 TlvTypeField::Custom(raw) => {
-                    return Err(TlvLvError::InvalidTlvTypeField {
+                    return Err(PduError::TlvLv(
+                        InvalidTlvTypeFieldError {
                             found: raw,
                             expected: None,
                         }
-                    .into());
+                        .into(),
+                    ));
                 }
             }
         }
@@ -355,10 +392,12 @@ impl<'buf> FinishedPduReader<'buf> {
 }
 
 impl CfdpPdu for FinishedPduReader<'_> {
+    #[inline]
     fn pdu_header(&self) -> &PduHeader {
-        &self.pdu_header
+        self.pdu_header()
     }
 
+    #[inline]
     fn file_directive_type(&self) -> Option<FileDirectiveType> {
         Some(FileDirectiveType::FinishedPdu)
     }
@@ -401,8 +440,8 @@ mod tests {
         delivery_code: DeliveryCode,
         file_status: FileStatus,
     ) -> FinishedPduCreator<'static> {
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_conf(crc_flag, fss), 0);
-        FinishedPduCreator::new_default(pdu_header, delivery_code, file_status)
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_conf(crc_flag, fss), 0);
+        FinishedPduCreator::new_no_error(pdu_header, delivery_code, file_status)
     }
 
     #[test]
@@ -563,7 +602,7 @@ mod tests {
         buf[written - 1] -= 1;
         let crc: u16 = ((buf[written - 2] as u16) << 8) as u16 | buf[written - 1] as u16;
         let error = FinishedPduReader::new(&buf).unwrap_err();
-        if let PduError::ChecksumError(e) = error {
+        if let PduError::Checksum(e) = error {
             assert_eq!(e, crc);
         } else {
             panic!("expected crc error");
@@ -572,8 +611,10 @@ mod tests {
 
     #[test]
     fn test_with_fault_location() {
-        let pdu_header =
-            PduHeader::new_no_file_data(common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal), 0);
+        let pdu_header = PduHeader::new_for_file_directive(
+            common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal),
+            0,
+        );
         let finished_pdu = FinishedPduCreator::new_with_error(
             pdu_header,
             ConditionCode::NakLimitReached,
@@ -594,8 +635,10 @@ mod tests {
 
     #[test]
     fn test_deserialization_with_fault_location() {
-        let pdu_header =
-            PduHeader::new_no_file_data(common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal), 0);
+        let pdu_header = PduHeader::new_for_file_directive(
+            common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal),
+            0,
+        );
         let entity_id_tlv = EntityIdTlv::new(TEST_DEST_ID.into());
         let finished_pdu = FinishedPduCreator::new_with_error(
             pdu_header,
@@ -630,9 +673,11 @@ mod tests {
         .unwrap();
         let fs_responses = &[fs_response_0, fs_response_1];
 
-        let pdu_header =
-            PduHeader::new_no_file_data(common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal), 0);
-        let finished_pdu = FinishedPduCreator::new_generic(
+        let pdu_header = PduHeader::new_for_file_directive(
+            common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal),
+            0,
+        );
+        let finished_pdu = FinishedPduCreator::new(
             pdu_header,
             ConditionCode::NakLimitReached,
             DeliveryCode::Incomplete,
@@ -665,9 +710,11 @@ mod tests {
         .unwrap();
         let fs_responses = &[fs_response_0, fs_response_1];
 
-        let pdu_header =
-            PduHeader::new_no_file_data(common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal), 0);
-        let finished_pdu = FinishedPduCreator::new_generic(
+        let pdu_header = PduHeader::new_for_file_directive(
+            common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal),
+            0,
+        );
+        let finished_pdu = FinishedPduCreator::new(
             pdu_header,
             ConditionCode::NakLimitReached,
             DeliveryCode::Incomplete,

src/cfdp/pdu/metadata.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "alloc")]
+use super::tlv::TlvOwned;
 use crate::cfdp::lv::Lv;
 use crate::cfdp::pdu::{
     add_pdu_crc, generic_length_checks_pdu_deserialization, read_fss_field, write_fss_field,
@@ -11,6 +13,7 @@ use alloc::vec::Vec;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use super::tlv::ReadableTlv;
 use super::{CfdpPdu, WritablePduPacket};
 
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq)]
@@ -51,6 +54,15 @@ pub fn build_metadata_opts_from_vec(
     build_metadata_opts_from_slice(buf, tlvs.as_slice())
 }
 
+#[cfg(feature = "alloc")]
+pub fn build_metadata_opts_from_owned_slice(tlvs: &[TlvOwned]) -> Vec<u8> {
+    let mut sum_vec = Vec::new();
+    for tlv in tlvs {
+        sum_vec.extend(tlv.to_vec());
+    }
+    sum_vec
+}
+
 /// Metadata PDU creator abstraction.
 ///
 /// This abstraction exposes a specialized API for creating metadata PDUs as specified in
@@ -61,7 +73,7 @@ pub struct MetadataPduCreator<'src_name, 'dest_name, 'opts> {
     metadata_params: MetadataGenericParams,
     src_file_name: Lv<'src_name>,
     dest_file_name: Lv<'dest_name>,
-    options: &'opts [Tlv<'opts>],
+    options: &'opts [u8],
 }
 
 impl<'src_name, 'dest_name, 'opts> MetadataPduCreator<'src_name, 'dest_name, 'opts> {
@@ -85,7 +97,7 @@ impl<'src_name, 'dest_name, 'opts> MetadataPduCreator<'src_name, 'dest_name, 'op
         metadata_params: MetadataGenericParams,
         src_file_name: Lv<'src_name>,
         dest_file_name: Lv<'dest_name>,
-        options: &'opts [Tlv<'opts>],
+        options: &'opts [u8],
     ) -> Self {
         Self::new(
             pdu_header,
@@ -101,7 +113,7 @@ impl<'src_name, 'dest_name, 'opts> MetadataPduCreator<'src_name, 'dest_name, 'op
         metadata_params: MetadataGenericParams,
         src_file_name: Lv<'src_name>,
         dest_file_name: Lv<'dest_name>,
-        options: &'opts [Tlv<'opts>],
+        options: &'opts [u8],
     ) -> Self {
         pdu_header.pdu_type = PduType::FileDirective;
         pdu_header.pdu_conf.direction = Direction::TowardsReceiver;
@@ -116,22 +128,40 @@ impl<'src_name, 'dest_name, 'opts> MetadataPduCreator<'src_name, 'dest_name, 'op
         pdu
     }
 
+    #[inline]
     pub fn metadata_params(&self) -> &MetadataGenericParams {
         &self.metadata_params
     }
 
+    #[inline]
     pub fn src_file_name(&self) -> Lv<'src_name> {
         self.src_file_name
     }
 
+    #[inline]
     pub fn dest_file_name(&self) -> Lv<'dest_name> {
         self.dest_file_name
     }
 
-    pub fn options(&self) -> &'opts [Tlv<'opts>] {
+    #[inline]
+    pub fn pdu_header(&self) -> &PduHeader {
+        &self.pdu_header
+    }
+
+    #[inline]
+    pub fn options(&self) -> &'opts [u8] {
         self.options
     }
 
+    /// Yield an iterator which can be used to loop through all options. Returns [None] if the
+    /// options field is empty.
+    pub fn options_iter(&self) -> OptionsIter<'_> {
+        OptionsIter {
+            opt_buf: self.options,
+            current_idx: 0,
+        }
+    }
+
     fn calc_pdu_datafield_len(&self) -> usize {
         // One directve type octet and one byte of the directive parameter field.
         let mut len = 2;
@@ -142,28 +172,15 @@ impl<'src_name, 'dest_name, 'opts> MetadataPduCreator<'src_name, 'dest_name, 'op
         }
         len += self.src_file_name.len_full();
         len += self.dest_file_name.len_full();
-        for tlv in self.options() {
-            len += tlv.len_full()
-        }
+        len += self.options().len();
         if self.crc_flag() == CrcFlag::WithCrc {
             len += 2;
         }
         len
     }
-}
 
-impl CfdpPdu for MetadataPduCreator<'_, '_, '_> {
-    fn pdu_header(&self) -> &PduHeader {
-        &self.pdu_header
-    }
-
-    fn file_directive_type(&self) -> Option<FileDirectiveType> {
-        Some(FileDirectiveType::MetadataPdu)
-    }
-}
-
-impl WritablePduPacket for MetadataPduCreator<'_, '_, '_> {
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+    /// Write [Self] to the provided buffer and returns the written size.
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
         let expected_len = self.len_written();
         if buf.len() < expected_len {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -190,21 +207,41 @@ impl WritablePduPacket for MetadataPduCreator<'_, '_, '_> {
         current_idx += self
             .dest_file_name
             .write_to_be_bytes(&mut buf[current_idx..])?;
-        for opt in self.options() {
-            opt.write_to_bytes(&mut buf[current_idx..current_idx + opt.len_full()])?;
-            current_idx += opt.len_full();
-        }
+        buf[current_idx..current_idx + self.options.len()].copy_from_slice(self.options);
+        current_idx += self.options.len();
         if self.crc_flag() == CrcFlag::WithCrc {
             current_idx = add_pdu_crc(buf, current_idx);
         }
         Ok(current_idx)
     }
 
-    fn len_written(&self) -> usize {
+    pub fn len_written(&self) -> usize {
         self.pdu_header.header_len() + self.calc_pdu_datafield_len()
     }
 }
 
+impl CfdpPdu for MetadataPduCreator<'_, '_, '_> {
+    #[inline]
+    fn pdu_header(&self) -> &PduHeader {
+        self.pdu_header()
+    }
+
+    #[inline]
+    fn file_directive_type(&self) -> Option<FileDirectiveType> {
+        Some(FileDirectiveType::MetadataPdu)
+    }
+}
+
+impl WritablePduPacket for MetadataPduCreator<'_, '_, '_> {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
+        self.write_to_bytes(buf)
+    }
+
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
 /// Helper structure to loop through all options of a metadata PDU. It should be noted that
 /// iterators in Rust are not fallible, but the TLV creation can fail, for example if the raw TLV
 /// data is invalid for some reason. In that case, the iterator will yield [None] because there
@@ -313,26 +350,36 @@ impl<'raw> MetadataPduReader<'raw> {
         })
     }
 
+    #[inline]
+    pub fn pdu_header(&self) -> &PduHeader {
+        &self.pdu_header
+    }
+
+    #[inline]
     pub fn options(&self) -> &'raw [u8] {
         self.options
     }
 
+    #[inline]
     pub fn metadata_params(&self) -> &MetadataGenericParams {
         &self.metadata_params
     }
 
-    pub fn src_file_name(&self) -> Lv {
+    #[inline]
+    pub fn src_file_name(&self) -> Lv<'_> {
         self.src_file_name
     }
 
-    pub fn dest_file_name(&self) -> Lv {
+    #[inline]
+    pub fn dest_file_name(&self) -> Lv<'_> {
         self.dest_file_name
     }
 }
 
 impl CfdpPdu for MetadataPduReader<'_> {
+    #[inline]
     fn pdu_header(&self) -> &PduHeader {
-        &self.pdu_header
+        self.pdu_header()
     }
 
     fn file_directive_type(&self) -> Option<FileDirectiveType> {
@@ -354,7 +401,7 @@ pub mod tests {
     };
     use crate::cfdp::pdu::{CfdpPdu, PduError, WritablePduPacket};
     use crate::cfdp::pdu::{FileDirectiveType, PduHeader};
-    use crate::cfdp::tlv::{Tlv, TlvType};
+    use crate::cfdp::tlv::{ReadableTlv, Tlv, TlvOwned, TlvType, WritableTlv};
     use crate::cfdp::{
         ChecksumType, CrcFlag, Direction, LargeFileFlag, PduType, SegmentMetadataFlag,
         SegmentationControl, TransmissionMode,
@@ -364,18 +411,18 @@ pub mod tests {
     const SRC_FILENAME: &str = "hello-world.txt";
     const DEST_FILENAME: &str = "hello-world2.txt";
 
-    fn generic_metadata_pdu<'opts>(
+    fn generic_metadata_pdu(
         crc_flag: CrcFlag,
         checksum_type: ChecksumType,
         closure_requested: bool,
         fss: LargeFileFlag,
-        opts: &'opts [Tlv],
+        opts: &[u8],
     ) -> (
         Lv<'static>,
         Lv<'static>,
-        MetadataPduCreator<'static, 'static, 'opts>,
+        MetadataPduCreator<'static, 'static, '_>,
     ) {
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_conf(crc_flag, fss), 0);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_conf(crc_flag, fss), 0);
         let metadata_params = MetadataGenericParams::new(closure_requested, checksum_type, 0x1010);
         let src_filename = Lv::new_from_str(SRC_FILENAME).expect("Generating string LV failed");
         let dest_filename =
@@ -543,9 +590,9 @@ pub mod tests {
         assert_eq!(written.metadata_params(), read.metadata_params());
         assert_eq!(written.src_file_name(), read.src_file_name());
         assert_eq!(written.dest_file_name(), read.dest_file_name());
-        let opts = written.options();
-        for (tlv_written, tlv_read) in opts.iter().zip(read.options_iter().unwrap()) {
-            assert_eq!(tlv_written, &tlv_read);
+        let opts = written.options_iter();
+        for (tlv_written, tlv_read) in opts.zip(read.options_iter().unwrap()) {
+            assert_eq!(&tlv_written, &tlv_read);
         }
     }
 
@@ -660,14 +707,14 @@ pub mod tests {
         let tlv1 = Tlv::new_empty(TlvType::FlowLabel);
         let msg_to_user: [u8; 4] = [1, 2, 3, 4];
         let tlv2 = Tlv::new(TlvType::MsgToUser, &msg_to_user).unwrap();
-        let tlv_vec = vec![tlv1, tlv2];
-        let opts_len = tlv1.len_full() + tlv2.len_full();
+        let mut tlv_buf: [u8; 64] = [0; 64];
+        let opts_len = build_metadata_opts_from_slice(&mut tlv_buf, &[tlv1, tlv2]).unwrap();
         let (src_filename, dest_filename, metadata_pdu) = generic_metadata_pdu(
             CrcFlag::NoCrc,
             ChecksumType::Crc32,
             false,
             LargeFileFlag::Normal,
-            &tlv_vec,
+            &tlv_buf[0..opts_len],
         );
         let mut buf: [u8; 128] = [0; 128];
         let write_res = metadata_pdu.write_to_bytes(&mut buf);
@@ -690,7 +737,55 @@ pub mod tests {
         let opts_iter = opts_iter.unwrap();
         let mut accumulated_len = 0;
         for (idx, opt) in opts_iter.enumerate() {
-            assert_eq!(tlv_vec[idx], opt);
+            if idx == 0 {
+                assert_eq!(tlv1, opt);
+            } else if idx == 1 {
+                assert_eq!(tlv2, opt);
+            }
+            accumulated_len += opt.len_full();
+        }
+        assert_eq!(accumulated_len, pdu_read_back.options().len());
+    }
+    #[test]
+    fn test_with_owned_opts() {
+        let tlv1 = TlvOwned::new_empty(TlvType::FlowLabel);
+        let msg_to_user: [u8; 4] = [1, 2, 3, 4];
+        let tlv2 = TlvOwned::new(TlvType::MsgToUser, &msg_to_user);
+        let mut all_tlvs = tlv1.to_vec();
+        all_tlvs.extend(tlv2.to_vec());
+        let (src_filename, dest_filename, metadata_pdu) = generic_metadata_pdu(
+            CrcFlag::NoCrc,
+            ChecksumType::Crc32,
+            false,
+            LargeFileFlag::Normal,
+            &all_tlvs,
+        );
+        let mut buf: [u8; 128] = [0; 128];
+        let write_res = metadata_pdu.write_to_bytes(&mut buf);
+        assert!(write_res.is_ok());
+        let written = write_res.unwrap();
+        assert_eq!(
+            written,
+            metadata_pdu.pdu_header.header_len()
+                + 1
+                + 1
+                + 4
+                + src_filename.len_full()
+                + dest_filename.len_full()
+                + all_tlvs.len()
+        );
+        let pdu_read_back = MetadataPduReader::from_bytes(&buf).unwrap();
+        compare_read_pdu_to_written_pdu(&metadata_pdu, &pdu_read_back);
+        let opts_iter = pdu_read_back.options_iter();
+        assert!(opts_iter.is_some());
+        let opts_iter = opts_iter.unwrap();
+        let mut accumulated_len = 0;
+        for (idx, opt) in opts_iter.enumerate() {
+            if idx == 0 {
+                assert_eq!(tlv1, opt);
+            } else if idx == 1 {
+                assert_eq!(tlv2, opt);
+            }
             accumulated_len += opt.len_full();
         }
         assert_eq!(accumulated_len, pdu_read_back.options().len());
@@ -715,7 +810,7 @@ pub mod tests {
             assert_eq!(expected, Some(FileDirectiveType::MetadataPdu));
             assert_eq!(
                 error.to_string(),
-                "invalid directive type value 255, expected Some(MetadataPdu)"
+                "invalid directive type, found 255, expected Some(MetadataPdu)"
             );
         } else {
             panic!("Expected InvalidDirectiveType error, got {:?}", error);
@@ -741,7 +836,7 @@ pub mod tests {
             assert_eq!(expected, FileDirectiveType::MetadataPdu);
             assert_eq!(
                 error.to_string(),
-                "found directive type EofPdu, expected MetadataPdu"
+                "wrong directive type, found EofPdu, expected MetadataPdu"
             );
         } else {
             panic!("Expected InvalidDirectiveType error, got {:?}", error);

src/cfdp/pdu/mod.rs

@@ -1,13 +1,12 @@
 //! CFDP Packet Data Unit (PDU) support.
+use crate::cfdp::pdu::ack::InvalidAckedDirectiveCodeError;
+use crate::cfdp::pdu::nak::InvalidStartOrEndOfScopeError;
 use crate::cfdp::*;
+use crate::crc::CRC_CCITT_FALSE;
 use crate::util::{UnsignedByteField, UnsignedByteFieldU8, UnsignedEnum};
 use crate::ByteConversionError;
-use crate::CRC_CCITT_FALSE;
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
-use core::fmt::{Display, Formatter};
-#[cfg(feature = "std")]
-use std::error::Error;
 
 pub mod ack;
 pub mod eof;
@@ -30,136 +29,70 @@ pub enum FileDirectiveType {
     KeepAlivePdu = 0x0c,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum PduError {
-    ByteConversion(ByteConversionError),
-    /// Found version ID invalid, not equal to [CFDP_VERSION_2].
+    #[error("byte conversion error: {0}")]
+    ByteConversion(#[from] ByteConversionError),
+    /// Found version ID invalid, not equal to [super::CFDP_VERSION_2].
+    #[error("CFDP version missmatch, found {0}, expected {ver}", ver = super::CFDP_VERSION_2)]
     CfdpVersionMissmatch(u8),
     /// Invalid length for the entity ID detected. Only the values 1, 2, 4 and 8 are supported.
+    #[error("invalid PDU entity ID length {0}, only [1, 2, 4, 8] are allowed")]
     InvalidEntityLen(u8),
     /// Invalid length for the entity ID detected. Only the values 1, 2, 4 and 8 are supported.
+    #[error("invalid transaction ID length {0}")]
     InvalidTransactionSeqNumLen(u8),
+    #[error(
+        "missmatch of PDU source ID length {src_id_len} and destination ID length {dest_id_len}"
+    )]
     SourceDestIdLenMissmatch {
         src_id_len: usize,
         dest_id_len: usize,
     },
     /// Wrong directive type, for example when parsing the directive field for a file directive
     /// PDU.
+    #[error("wrong directive type, found {found:?}, expected {expected:?}")]
     WrongDirectiveType {
         found: FileDirectiveType,
         expected: FileDirectiveType,
     },
     /// The directive type field contained a value not in the range of permitted values. This can
-    /// also happen if an invalid value is passed to the ACK PDU constructor.
+    /// also happen if an invalid value is passed to the ACK PDU reader.
+    #[error("invalid directive type, found {found:?}, expected {expected:?}")]
     InvalidDirectiveType {
         found: u8,
         expected: Option<FileDirectiveType>,
     },
-    InvalidStartOrEndOfScopeValue,
+    #[error("nak pdu: {0}")]
+    InvalidStartOrEndOfScope(#[from] InvalidStartOrEndOfScopeError),
     /// Invalid condition code. Contains the raw detected value.
+    #[error("invalid condition code {0}")]
     InvalidConditionCode(u8),
     /// Invalid checksum type which is not part of the checksums listed in the
     /// [SANA Checksum Types registry](https://sanaregistry.org/r/checksum_identifiers/).
+    #[error("invalid checksum type {0}")]
     InvalidChecksumType(u8),
+    #[error("file size {0} too large")]
     FileSizeTooLarge(u64),
     /// If the CRC flag for a PDU is enabled and the checksum check fails. Contains raw 16-bit CRC.
-    ChecksumError(u16),
+    #[error("checksum error for checksum {0}")]
+    Checksum(u16),
     /// Generic error for invalid PDU formats.
-    FormatError,
+    #[error("generic PDU format error")]
+    Format,
     /// Error handling a TLV field.
-    TlvLvError(TlvLvError),
+    #[error("PDU error: {0}")]
+    TlvLv(#[from] TlvLvError),
 }
 
-impl Display for PduError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            PduError::InvalidEntityLen(raw_id) => {
-                write!(
-                    f,
-                    "invalid PDU entity ID length {raw_id}, only [1, 2, 4, 8] are allowed"
-                )
+impl From<InvalidAckedDirectiveCodeError> for PduError {
+    fn from(value: InvalidAckedDirectiveCodeError) -> Self {
+        Self::InvalidDirectiveType {
+            found: value.0 as u8,
+            expected: None,
         }
-            PduError::InvalidStartOrEndOfScopeValue => {
-                write!(f, "invalid start or end of scope for NAK PDU")
-            }
-            PduError::InvalidTransactionSeqNumLen(raw_id) => {
-                write!(
-                    f,
-                    "invalid PDUtransaction seq num length {raw_id}, only [1, 2, 4, 8] are allowed"
-                )
-            }
-            PduError::CfdpVersionMissmatch(raw) => {
-                write!(
-                    f,
-                    "cfdp version missmatch, found {raw}, expected {CFDP_VERSION_2}"
-                )
-            }
-            PduError::SourceDestIdLenMissmatch {
-                src_id_len,
-                dest_id_len,
-            } => {
-                write!(
-                    f,
-                    "missmatch of PDU source length {src_id_len} and destination length {dest_id_len}"
-                )
-            }
-            PduError::ByteConversion(e) => {
-                write!(f, "{}", e)
-            }
-            PduError::FileSizeTooLarge(value) => {
-                write!(f, "file size value {value} exceeds allowed 32 bit width")
-            }
-            PduError::WrongDirectiveType { found, expected } => {
-                write!(f, "found directive type {found:?}, expected {expected:?}")
-            }
-            PduError::InvalidConditionCode(raw_code) => {
-                write!(f, "found invalid condition code with raw value {raw_code}")
-            }
-            PduError::InvalidDirectiveType { found, expected } => {
-                write!(
-                    f,
-                    "invalid directive type value {found}, expected {expected:?}"
-                )
-            }
-            PduError::InvalidChecksumType(checksum_type) => {
-                write!(f, "invalid checksum type {checksum_type}")
-            }
-            PduError::ChecksumError(checksum) => {
-                write!(f, "checksum error for CRC {checksum:#04x}")
-            }
-            PduError::TlvLvError(error) => {
-                write!(f, "pdu tlv error: {error}")
-            }
-            PduError::FormatError => {
-                write!(f, "generic PDU format error")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for PduError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            PduError::ByteConversion(e) => Some(e),
-            PduError::TlvLvError(e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-impl From<ByteConversionError> for PduError {
-    #[inline]
-    fn from(value: ByteConversionError) -> Self {
-        Self::ByteConversion(value)
-    }
-}
-
-impl From<TlvLvError> for PduError {
-    #[inline]
-    fn from(e: TlvLvError) -> Self {
-        Self::TlvLvError(e)
     }
 }
 
@@ -389,6 +322,8 @@ pub struct PduHeader {
 }
 
 impl PduHeader {
+    pub const FIXED_LEN: usize = FIXED_HEADER_LEN;
+
     #[inline]
     pub fn new_for_file_data(
         pdu_conf: CommonPduConfig,
@@ -415,8 +350,9 @@ impl PduHeader {
             SegmentationControl::NoRecordBoundaryPreservation,
         )
     }
+
     #[inline]
-    pub fn new_no_file_data(pdu_conf: CommonPduConfig, pdu_datafield_len: u16) -> Self {
+    pub fn new_for_file_directive(pdu_conf: CommonPduConfig, pdu_datafield_len: u16) -> Self {
         Self::new_generic(
             PduType::FileDirective,
             pdu_conf,
@@ -426,6 +362,17 @@ impl PduHeader {
         )
     }
 
+    #[inline]
+    pub fn from_pdu_conf_for_file_directive(pdu_conf: CommonPduConfig) -> Self {
+        Self::new_generic(
+            PduType::FileDirective,
+            pdu_conf,
+            0,
+            SegmentMetadataFlag::NotPresent,
+            SegmentationControl::NoRecordBoundaryPreservation,
+        )
+    }
+
     #[inline]
     pub fn new_generic(
         pdu_type: PduType,
@@ -464,15 +411,14 @@ impl PduHeader {
         self.header_len() + self.pdu_datafield_len as usize
     }
 
-    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, PduError> {
-        // Internal note: There is currently no way to pass a PDU configuration like this, but
-        // this check is still kept for defensive programming.
-        if self.pdu_conf.source_entity_id.size() != self.pdu_conf.dest_entity_id.size() {
-            return Err(PduError::SourceDestIdLenMissmatch {
-                src_id_len: self.pdu_conf.source_entity_id.size(),
-                dest_id_len: self.pdu_conf.dest_entity_id.size(),
-            });
-        }
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        // The API does not allow passing entity IDs with different sizes, so this should
+        // never happen.
+        assert_eq!(
+            self.pdu_conf.source_entity_id.size(),
+            self.pdu_conf.dest_entity_id.size(),
+            "unexpected missmatch of source and destination entity ID length"
+        );
         if buf.len()
             < FIXED_HEADER_LEN
                 + self.pdu_conf.source_entity_id.size()
@@ -481,8 +427,7 @@ impl PduHeader {
             return Err(ByteConversionError::ToSliceTooSmall {
                 found: buf.len(),
                 expected: FIXED_HEADER_LEN,
-            }
-            .into());
+            });
         }
         let mut current_idx = 0;
         buf[current_idx] = (CFDP_VERSION_2 << 5)
@@ -532,7 +477,7 @@ impl PduHeader {
             let mut digest = CRC_CCITT_FALSE.digest();
             digest.update(&buf[..self.pdu_len()]);
             if digest.finalize() != 0 {
-                return Err(PduError::ChecksumError(u16::from_be_bytes(
+                return Err(PduError::Checksum(u16::from_be_bytes(
                     buf[self.pdu_len() - 2..self.pdu_len()].try_into().unwrap(),
                 )));
             }
@@ -643,6 +588,7 @@ impl PduHeader {
         &self.pdu_conf
     }
 
+    #[inline]
     pub fn seg_metadata_flag(&self) -> SegmentMetadataFlag {
         self.seg_metadata_flag
     }
@@ -812,7 +758,7 @@ mod tests {
         let transaction_id = UnsignedByteFieldU8::new(3);
         let common_pdu_cfg = CommonPduConfig::new_with_byte_fields(src_id, dest_id, transaction_id)
             .expect("common config creation failed");
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_cfg, 5);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_cfg, 5);
         assert_eq!(pdu_header.pdu_type(), PduType::FileDirective);
         let common_conf_ref = pdu_header.common_pdu_conf();
         assert_eq!(*common_conf_ref, common_pdu_cfg);
@@ -878,7 +824,7 @@ mod tests {
         let transaction_id = UnsignedByteFieldU8::new(3);
         let common_pdu_cfg = CommonPduConfig::new_with_byte_fields(src_id, dest_id, transaction_id)
             .expect("common config creation failed");
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_cfg, 5);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_cfg, 5);
         let mut buf: [u8; 7] = [0; 7];
         let res = pdu_header.write_to_bytes(&mut buf);
         assert!(res.is_ok());
@@ -895,7 +841,7 @@ mod tests {
         let transaction_id = UnsignedByteFieldU8::new(3);
         let common_pdu_cfg = CommonPduConfig::new_with_byte_fields(src_id, dest_id, transaction_id)
             .expect("common config creation failed");
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_cfg, 5);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_cfg, 5);
         let mut buf: [u8; 7] = [0; 7];
         let res = pdu_header.write_to_bytes(&mut buf);
         assert!(res.is_ok());
@@ -968,7 +914,7 @@ mod tests {
         let transaction_id = UnsignedByteFieldU8::new(3);
         let common_pdu_cfg = CommonPduConfig::new_with_byte_fields(src_id, dest_id, transaction_id)
             .expect("common config creation failed");
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_cfg, 5);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_cfg, 5);
         let mut buf: [u8; 7] = [0; 7];
         let res = pdu_header.write_to_bytes(&mut buf);
         assert!(res.is_ok());
@@ -981,7 +927,7 @@ mod tests {
             assert_eq!(raw_version, CFDP_VERSION_2 + 1);
             assert_eq!(
                 error.to_string(),
-                "cfdp version missmatch, found 2, expected 1"
+                "CFDP version missmatch, found 2, expected 1"
             );
         } else {
             panic!("invalid exception: {}", error);
@@ -1013,7 +959,7 @@ mod tests {
         let transaction_id = UnsignedByteFieldU8::new(3);
         let common_pdu_cfg = CommonPduConfig::new_with_byte_fields(src_id, dest_id, transaction_id)
             .expect("common config creation failed");
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_cfg, 5);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_cfg, 5);
         let mut buf: [u8; 7] = [0; 7];
         let res = pdu_header.write_to_bytes(&mut buf);
         assert!(res.is_ok());
@@ -1029,7 +975,7 @@ mod tests {
             assert_eq!(expected, 7);
             assert_eq!(
                 error.to_string(),
-                "source slice with size 6 too small, expected at least 7 bytes"
+                "byte conversion error: source slice with size 6 too small, expected at least 7 bytes"
             );
         }
     }
@@ -1084,7 +1030,7 @@ mod tests {
             assert_eq!(dest_id_len, 2);
             assert_eq!(
                 error.to_string(),
-                "missmatch of PDU source length 1 and destination length 2"
+                "missmatch of PDU source ID length 1 and destination ID length 2"
             );
         }
     }
@@ -1096,7 +1042,7 @@ mod tests {
         let transaction_id = UnsignedByteFieldU8::new(3);
         let common_pdu_cfg = CommonPduConfig::new_with_byte_fields(src_id, dest_id, transaction_id)
             .expect("common config creation failed");
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_cfg, 5);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_cfg, 5);
         let mut buf: [u8; 7] = [0; 7];
         let res = pdu_header.write_to_bytes(&mut buf);
         assert!(res.is_ok());
@@ -1120,7 +1066,7 @@ mod tests {
         let transaction_id = UnsignedByteFieldU8::new(3);
         let common_pdu_cfg = CommonPduConfig::new_with_byte_fields(src_id, dest_id, transaction_id)
             .expect("common config creation failed");
-        let pdu_header = PduHeader::new_no_file_data(common_pdu_cfg, 5);
+        let pdu_header = PduHeader::new_for_file_directive(common_pdu_cfg, 5);
         let mut buf: [u8; 7] = [0; 7];
         let res = pdu_header.write_to_bytes(&mut buf);
         assert!(res.is_ok());
@@ -1152,4 +1098,12 @@ mod tests {
         let common_pdu_cfg_1 = common_pdu_cfg_0;
         assert_eq!(common_pdu_cfg_0, common_pdu_cfg_1);
     }
+
+    #[test]
+    fn test_ctor_from_pdu_conf() {
+        assert_eq!(
+            PduHeader::from_pdu_conf_for_file_directive(CommonPduConfig::default()),
+            PduHeader::new_for_file_directive(CommonPduConfig::default(), 0)
+        );
+    }
 }

src/cfdp/tlv/mod.rs

@@ -9,10 +9,14 @@ use crate::ByteConversionError;
 use alloc::vec;
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
+#[cfg(feature = "alloc")]
+pub use alloc_mod::*;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use super::{InvalidTlvTypeFieldError, TlvLvDataTooLargeError};
+
 pub mod msg_to_user;
 
 pub const MIN_TLV_LEN: usize = 2;
@@ -22,6 +26,7 @@ pub trait GenericTlv {
 
     /// Checks whether the type field contains one of the standard types specified in the CFDP
     /// standard and is part of the [TlvType] enum.
+    #[inline]
     fn is_standard_tlv(&self) -> bool {
         if let TlvTypeField::Standard(_) = self.tlv_type_field() {
             return true;
@@ -30,6 +35,7 @@ pub trait GenericTlv {
     }
 
     /// Returns the standard TLV type if the TLV field is not a custom field
+    #[inline]
     fn tlv_type(&self) -> Option<TlvType> {
         if let TlvTypeField::Standard(tlv_type) = self.tlv_type_field() {
             Some(tlv_type)
@@ -39,6 +45,29 @@ pub trait GenericTlv {
     }
 }
 
+pub trait ReadableTlv {
+    fn value(&self) -> &[u8];
+
+    /// Checks whether the value field is empty.
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.value().is_empty()
+    }
+
+    /// Helper method to retrieve the length of the value. Simply calls the [slice::len] method of
+    /// [Self::value]
+    #[inline]
+    fn len_value(&self) -> usize {
+        self.value().len()
+    }
+
+    /// Returns the full raw length, including the length byte.
+    #[inline]
+    fn len_full(&self) -> usize {
+        self.len_value() + 2
+    }
+}
+
 pub trait WritableTlv {
     fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
     fn len_written(&self) -> usize;
@@ -129,14 +158,19 @@ pub struct Tlv<'data> {
 }
 
 impl<'data> Tlv<'data> {
-    pub fn new(tlv_type: TlvType, data: &[u8]) -> Result<Tlv, TlvLvError> {
+    pub const MIN_LEN: usize = MIN_TLV_LEN;
+
+    pub fn new(tlv_type: TlvType, data: &[u8]) -> Result<Tlv<'_>, TlvLvDataTooLargeError> {
         Ok(Tlv {
             tlv_type_field: TlvTypeField::Standard(tlv_type),
             lv: Lv::new(data)?,
         })
     }
 
-    pub fn new_with_custom_type(tlv_type: u8, data: &[u8]) -> Result<Tlv, TlvLvError> {
+    pub fn new_with_custom_type(
+        tlv_type: u8,
+        data: &[u8],
+    ) -> Result<Tlv<'_>, TlvLvDataTooLargeError> {
         Ok(Tlv {
             tlv_type_field: TlvTypeField::Custom(tlv_type),
             lv: Lv::new(data)?,
@@ -151,31 +185,11 @@ impl<'data> Tlv<'data> {
         }
     }
 
-    pub fn value(&self) -> &[u8] {
-        self.lv.value()
-    }
-
-    /// Checks whether the value field is empty.
-    pub fn is_empty(&self) -> bool {
-        self.value().is_empty()
-    }
-
-    /// Helper method to retrieve the length of the value. Simply calls the [slice::len] method of
-    /// [Self::value]
-    pub fn len_value(&self) -> usize {
-        self.value().len()
-    }
-
-    /// Returns the full raw length, including the length byte.
-    pub fn len_full(&self) -> usize {
-        self.len_value() + 2
-    }
-
     /// Creates a TLV give a raw bytestream. Please note that is is not necessary to pass the
     /// bytestream with the exact size of the expected TLV. This function will take care
     /// of parsing the length byte, and the length of the parsed TLV can be retrieved using
     /// [Self::len_full].
-    pub fn from_bytes(buf: &'data [u8]) -> Result<Tlv<'data>, TlvLvError> {
+    pub fn from_bytes(buf: &'data [u8]) -> Result<Tlv<'data>, ByteConversionError> {
         generic_len_check_deserialization(buf, MIN_TLV_LEN)?;
         let mut tlv = Self {
             tlv_type_field: TlvTypeField::from(buf[0]),
@@ -189,9 +203,31 @@ impl<'data> Tlv<'data> {
 
     /// If the TLV was generated from a raw bytestream using [Self::from_bytes], the raw start
     /// of the TLV can be retrieved with this method.
+    #[inline]
     pub fn raw_data(&self) -> Option<&[u8]> {
         self.lv.raw_data()
     }
+
+    #[cfg(feature = "alloc")]
+    pub fn to_owned(&self) -> TlvOwned {
+        TlvOwned {
+            tlv_type_field: self.tlv_type_field,
+            data: self.value().to_vec(),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl PartialEq<TlvOwned> for Tlv<'_> {
+    fn eq(&self, other: &TlvOwned) -> bool {
+        self.tlv_type_field == other.tlv_type_field && self.value() == other.value()
+    }
+}
+
+impl ReadableTlv for Tlv<'_> {
+    fn value(&self) -> &[u8] {
+        self.lv.value()
+    }
 }
 
 impl WritableTlv for Tlv<'_> {
@@ -201,29 +237,116 @@ impl WritableTlv for Tlv<'_> {
         self.lv.write_to_be_bytes_no_len_check(&mut buf[1..]);
         Ok(self.len_full())
     }
+
+    #[inline]
     fn len_written(&self) -> usize {
         self.len_full()
     }
 }
 
 impl GenericTlv for Tlv<'_> {
+    #[inline]
     fn tlv_type_field(&self) -> TlvTypeField {
         self.tlv_type_field
     }
 }
 
-pub(crate) fn verify_tlv_type(raw_type: u8, expected_tlv_type: TlvType) -> Result<(), TlvLvError> {
-    let tlv_type = TlvType::try_from(raw_type).map_err(|_| TlvLvError::InvalidTlvTypeField {
-        found: raw_type,
-        expected: Some(expected_tlv_type.into()),
-    })?;
-    if tlv_type != expected_tlv_type {
-        return Err(TlvLvError::InvalidTlvTypeField {
-            found: tlv_type as u8,
-            expected: Some(expected_tlv_type as u8),
-        });
+#[cfg(feature = "alloc")]
+pub mod alloc_mod {
+    use super::*;
+
+    /// Owned variant of [Tlv] which is consequently [Clone]able and does not have a lifetime
+    /// associated to a data slice.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    pub struct TlvOwned {
+        pub(crate) tlv_type_field: TlvTypeField,
+        pub(crate) data: Vec<u8>,
+    }
+
+    impl TlvOwned {
+        pub fn new(tlv_type: TlvType, data: &[u8]) -> Self {
+            Self {
+                tlv_type_field: TlvTypeField::Standard(tlv_type),
+                data: data.to_vec(),
+            }
+        }
+
+        pub fn new_with_custom_type(tlv_type: u8, data: &[u8]) -> Self {
+            Self {
+                tlv_type_field: TlvTypeField::Custom(tlv_type),
+                data: data.to_vec(),
+            }
+        }
+
+        /// Creates a TLV with an empty value field.
+        pub fn new_empty(tlv_type: TlvType) -> Self {
+            Self {
+                tlv_type_field: TlvTypeField::Standard(tlv_type),
+                data: Vec::new(),
+            }
+        }
+
+        pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+            generic_len_check_data_serialization(buf, self.data.len(), MIN_TLV_LEN)?;
+            buf[0] = self.tlv_type_field.into();
+            buf[1] = self.data.len() as u8;
+            buf[2..2 + self.data.len()].copy_from_slice(&self.data);
+            Ok(self.len_written())
+        }
+
+        #[inline]
+        fn len_written(&self) -> usize {
+            self.data.len() + 2
+        }
+
+        pub fn as_tlv(&self) -> Tlv<'_> {
+            Tlv {
+                tlv_type_field: self.tlv_type_field,
+                // The API should ensure that the data length is never to large, so the unwrap for the
+                // LV creation should never be an issue.
+                lv: Lv::new(&self.data).expect("lv creation failed unexpectedly"),
+            }
+        }
+    }
+
+    impl ReadableTlv for TlvOwned {
+        #[inline]
+        fn value(&self) -> &[u8] {
+            &self.data
+        }
+    }
+
+    impl WritableTlv for TlvOwned {
+        fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+            self.write_to_bytes(buf)
+        }
+
+        #[inline]
+        fn len_written(&self) -> usize {
+            self.len_written()
+        }
+    }
+
+    impl GenericTlv for TlvOwned {
+        #[inline]
+        fn tlv_type_field(&self) -> TlvTypeField {
+            self.tlv_type_field
+        }
+    }
+
+    impl From<Tlv<'_>> for TlvOwned {
+        fn from(value: Tlv<'_>) -> Self {
+            value.to_owned()
+        }
+    }
+
+    impl PartialEq<Tlv<'_>> for TlvOwned {
+        fn eq(&self, other: &Tlv) -> bool {
+            self.tlv_type_field == other.tlv_type_field && self.data == other.value()
+        }
     }
-    Ok(())
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -234,6 +357,7 @@ pub struct EntityIdTlv {
 }
 
 impl EntityIdTlv {
+    #[inline]
     pub fn new(entity_id: UnsignedByteField) -> Self {
         Self { entity_id }
     }
@@ -248,14 +372,17 @@ impl EntityIdTlv {
         Ok(())
     }
 
+    #[inline]
     pub fn entity_id(&self) -> &UnsignedByteField {
         &self.entity_id
     }
 
+    #[inline]
     pub fn len_value(&self) -> usize {
         self.entity_id.size()
     }
 
+    #[inline]
     pub fn len_full(&self) -> usize {
         2 + self.entity_id.size()
     }
@@ -273,19 +400,14 @@ impl EntityIdTlv {
     }
 
     /// Convert to a generic [Tlv], which also erases the programmatic type information.
-    pub fn to_tlv(self, buf: &mut [u8]) -> Result<Tlv, ByteConversionError> {
+    pub fn to_tlv(self, buf: &mut [u8]) -> Result<Tlv<'_>, ByteConversionError> {
         Self::len_check(buf)?;
         self.entity_id
             .write_to_be_bytes(&mut buf[2..2 + self.entity_id.size()])?;
-        Tlv::new(TlvType::EntityId, &buf[2..2 + self.entity_id.size()]).map_err(|e| match e {
-            TlvLvError::ByteConversion(e) => e,
-            // All other errors are impossible.
-            _ => panic!("unexpected TLV error"),
-        })
+        // Can't fail.
+        Ok(Tlv::new(TlvType::EntityId, &buf[2..2 + self.entity_id.size()]).unwrap())
     }
-}
 
-impl WritableTlv for EntityIdTlv {
     fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         Self::len_check(buf)?;
         buf[0] = TlvType::EntityId as u8;
@@ -293,35 +415,50 @@ impl WritableTlv for EntityIdTlv {
         Ok(2 + self.entity_id.write_to_be_bytes(&mut buf[2..])?)
     }
 
+    #[inline]
     fn len_written(&self) -> usize {
         self.len_full()
     }
 }
 
+impl WritableTlv for EntityIdTlv {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        self.write_to_bytes(buf)
+    }
+
+    #[inline]
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
 impl GenericTlv for EntityIdTlv {
+    #[inline]
     fn tlv_type_field(&self) -> TlvTypeField {
         TlvTypeField::Standard(TlvType::EntityId)
     }
 }
 
-impl<'data> TryFrom<Tlv<'data>> for EntityIdTlv {
+impl TryFrom<Tlv<'_>> for EntityIdTlv {
     type Error = TlvLvError;
 
-    fn try_from(value: Tlv) -> Result<Self, Self::Error> {
+    fn try_from(value: Tlv) -> Result<Self, TlvLvError> {
         match value.tlv_type_field {
             TlvTypeField::Standard(tlv_type) => {
                 if tlv_type != TlvType::EntityId {
-                    return Err(TlvLvError::InvalidTlvTypeField {
+                    return Err(InvalidTlvTypeFieldError {
                         found: tlv_type as u8,
                         expected: Some(TlvType::EntityId as u8),
-                    });
+                    }
+                    .into());
                 }
             }
             TlvTypeField::Custom(val) => {
-                return Err(TlvLvError::InvalidTlvTypeField {
+                return Err(InvalidTlvTypeFieldError {
                     found: val,
                     expected: Some(TlvType::EntityId as u8),
-                });
+                }
+                .into());
             }
         }
         let len_value = value.value().len();
@@ -341,6 +478,7 @@ impl<'data> TryFrom<Tlv<'data>> for EntityIdTlv {
     }
 }
 
+#[inline]
 pub fn fs_request_has_second_filename(action_code: FilestoreActionCode) -> bool {
     if action_code == FilestoreActionCode::RenameFile
         || action_code == FilestoreActionCode::AppendFile
@@ -363,6 +501,7 @@ struct FilestoreTlvBase<'first_name, 'second_name> {
 }
 
 impl FilestoreTlvBase<'_, '_> {
+    #[inline]
     fn base_len_value(&self) -> usize {
         let mut len = 1 + self.first_name.len_full();
         if let Some(second_name) = self.second_name {
@@ -472,22 +611,27 @@ impl<'first_name, 'second_name> FilestoreRequestTlv<'first_name, 'second_name> {
         })
     }
 
+    #[inline]
     pub fn action_code(&self) -> FilestoreActionCode {
         self.base.action_code
     }
 
+    #[inline]
     pub fn first_name(&self) -> Lv<'first_name> {
         self.base.first_name
     }
 
+    #[inline]
     pub fn second_name(&self) -> Option<Lv<'second_name>> {
         self.base.second_name
     }
 
+    #[inline]
     pub fn len_value(&self) -> usize {
         self.base.base_len_value()
     }
 
+    #[inline]
     pub fn len_full(&self) -> usize {
         2 + self.len_value()
     }
@@ -526,9 +670,7 @@ impl<'first_name, 'second_name> FilestoreRequestTlv<'first_name, 'second_name> {
             },
         })
     }
-}
 
-impl WritableTlv for FilestoreRequestTlv<'_, '_> {
     fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         if buf.len() < self.len_full() {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -554,12 +696,25 @@ impl WritableTlv for FilestoreRequestTlv<'_, '_> {
         Ok(current_idx)
     }
 
+    #[inline]
     fn len_written(&self) -> usize {
         self.len_full()
     }
 }
 
+impl WritableTlv for FilestoreRequestTlv<'_, '_> {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        self.write_to_bytes(buf)
+    }
+
+    #[inline]
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
 impl GenericTlv for FilestoreRequestTlv<'_, '_> {
+    #[inline]
     fn tlv_type_field(&self) -> TlvTypeField {
         TlvTypeField::Standard(TlvType::FilestoreRequest)
     }
@@ -634,26 +789,32 @@ impl<'first_name, 'second_name, 'fs_msg> FilestoreResponseTlv<'first_name, 'seco
         false
     }
 
+    #[inline]
     pub fn action_code(&self) -> FilestoreActionCode {
         self.base.action_code
     }
 
+    #[inline]
     pub fn status_code(&self) -> u8 {
         self.status_code
     }
 
+    #[inline]
     pub fn first_name(&self) -> Lv<'first_name> {
         self.base.first_name
     }
 
+    #[inline]
     pub fn second_name(&self) -> Option<Lv<'second_name>> {
         self.base.second_name
     }
 
+    #[inline]
     pub fn len_value(&self) -> usize {
         self.base.base_len_value() + self.filestore_message.len_full()
     }
 
+    #[inline]
     pub fn len_full(&self) -> usize {
         2 + self.len_value()
     }
@@ -711,9 +872,7 @@ impl<'first_name, 'second_name, 'fs_msg> FilestoreResponseTlv<'first_name, 'seco
             filestore_message,
         })
     }
-}
 
-impl WritableTlv for FilestoreResponseTlv<'_, '_, '_> {
     fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         if buf.len() < self.len_full() {
             return Err(ByteConversionError::ToSliceTooSmall {
@@ -746,12 +905,41 @@ impl WritableTlv for FilestoreResponseTlv<'_, '_, '_> {
     }
 }
 
+impl WritableTlv for FilestoreResponseTlv<'_, '_, '_> {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        self.write_to_bytes(buf)
+    }
+
+    #[inline]
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+}
+
 impl GenericTlv for FilestoreResponseTlv<'_, '_, '_> {
+    #[inline]
     fn tlv_type_field(&self) -> TlvTypeField {
         TlvTypeField::Standard(TlvType::FilestoreResponse)
     }
 }
 
+pub(crate) fn verify_tlv_type(
+    raw_type: u8,
+    expected_tlv_type: TlvType,
+) -> Result<(), InvalidTlvTypeFieldError> {
+    let tlv_type = TlvType::try_from(raw_type).map_err(|_| InvalidTlvTypeFieldError {
+        found: raw_type,
+        expected: Some(expected_tlv_type.into()),
+    })?;
+    if tlv_type != expected_tlv_type {
+        return Err(InvalidTlvTypeFieldError {
+            found: tlv_type as u8,
+            expected: Some(expected_tlv_type as u8),
+        });
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -939,14 +1127,14 @@ mod tests {
         let tlv_res = Tlv::new(TlvType::MsgToUser, &buf_too_large);
         assert!(tlv_res.is_err());
         let error = tlv_res.unwrap_err();
-        if let TlvLvError::DataTooLarge(size) = error {
+        match error {
+            TlvLvDataTooLargeError(size) => {
                 assert_eq!(size, u8::MAX as usize + 1);
                 assert_eq!(
                     error.to_string(),
                     "data with size 256 larger than allowed 255 bytes"
                 );
-        } else {
-            panic!("unexpected error {:?}", error);
+            }
         }
     }
 
@@ -1256,7 +1444,8 @@ mod tests {
         let error = EntityIdTlv::try_from(msg_to_user_tlv);
         assert!(error.is_err());
         let error = error.unwrap_err();
-        if let TlvLvError::InvalidTlvTypeField { found, expected } = error {
+        if let TlvLvError::InvalidTlvTypeField(InvalidTlvTypeFieldError { found, expected }) = error
+        {
             assert_eq!(found, TlvType::MsgToUser as u8);
             assert_eq!(expected, Some(TlvType::EntityId as u8));
             assert_eq!(
@@ -1300,4 +1489,71 @@ mod tests {
         assert_eq!(tlv_as_vec[0], 20);
         assert_eq!(tlv_as_vec[1], 0);
     }
+
+    #[test]
+    fn test_tlv_to_owned() {
+        let entity_id = UbfU8::new(5);
+        let mut buf: [u8; 4] = [0; 4];
+        assert!(entity_id.write_to_be_bytes(&mut buf).is_ok());
+        let tlv_res = Tlv::new(TlvType::EntityId, &buf[0..1]);
+        assert!(tlv_res.is_ok());
+        let tlv_res = tlv_res.unwrap();
+        let tlv_owned = tlv_res.to_owned();
+        assert_eq!(tlv_res, tlv_owned);
+        let tlv_owned_from_conversion: TlvOwned = tlv_res.into();
+        assert_eq!(tlv_owned_from_conversion, tlv_owned);
+        assert_eq!(tlv_owned_from_conversion, tlv_res);
+    }
+
+    #[test]
+    fn test_owned_tlv() {
+        let entity_id = UbfU8::new(5);
+        let mut buf: [u8; 4] = [0; 4];
+        assert!(entity_id.write_to_be_bytes(&mut buf).is_ok());
+        let tlv_res = TlvOwned::new(TlvType::EntityId, &buf[0..1]);
+        assert_eq!(
+            tlv_res.tlv_type_field(),
+            TlvTypeField::Standard(TlvType::EntityId)
+        );
+        assert_eq!(tlv_res.len_full(), 3);
+        assert_eq!(tlv_res.value().len(), 1);
+        assert_eq!(tlv_res.len_value(), 1);
+        assert!(!tlv_res.is_empty());
+        assert_eq!(tlv_res.value()[0], 5);
+    }
+
+    #[test]
+    fn test_owned_tlv_empty() {
+        let tlv_res = TlvOwned::new_empty(TlvType::FlowLabel);
+        assert_eq!(
+            tlv_res.tlv_type_field(),
+            TlvTypeField::Standard(TlvType::FlowLabel)
+        );
+        assert_eq!(tlv_res.len_full(), 2);
+        assert_eq!(tlv_res.value().len(), 0);
+        assert_eq!(tlv_res.len_value(), 0);
+        assert!(tlv_res.is_empty());
+    }
+
+    #[test]
+    fn test_owned_tlv_custom_type() {
+        let tlv_res = TlvOwned::new_with_custom_type(32, &[]);
+        assert_eq!(tlv_res.tlv_type_field(), TlvTypeField::Custom(32));
+        assert_eq!(tlv_res.len_full(), 2);
+        assert_eq!(tlv_res.value().len(), 0);
+        assert_eq!(tlv_res.len_value(), 0);
+        assert!(tlv_res.is_empty());
+    }
+
+    #[test]
+    fn test_owned_tlv_conversion_to_bytes() {
+        let entity_id = UbfU8::new(5);
+        let mut buf: [u8; 4] = [0; 4];
+        assert!(entity_id.write_to_be_bytes(&mut buf).is_ok());
+        let tlv_res = Tlv::new(TlvType::EntityId, &buf[0..1]);
+        assert!(tlv_res.is_ok());
+        let tlv_res = tlv_res.unwrap();
+        let tlv_owned_from_conversion: TlvOwned = tlv_res.into();
+        assert_eq!(tlv_res.to_vec(), tlv_owned_from_conversion.to_vec());
+    }
 }

src/cfdp/tlv/msg_to_user.rs

@@ -1,6 +1,11 @@
 //! Abstractions for the Message to User CFDP TLV subtype.
-use super::{GenericTlv, Tlv, TlvLvError, TlvType, TlvTypeField, WritableTlv};
-use crate::ByteConversionError;
+#[cfg(feature = "alloc")]
+use super::TlvOwned;
+use super::{GenericTlv, ReadableTlv, Tlv, TlvLvError, TlvType, TlvTypeField, WritableTlv};
+use crate::{
+    cfdp::{InvalidTlvTypeFieldError, TlvLvDataTooLargeError},
+    ByteConversionError,
+};
 use delegate::delegate;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -10,7 +15,7 @@ pub struct MsgToUserTlv<'data> {
 
 impl<'data> MsgToUserTlv<'data> {
     /// Create a new message to user TLV where the type field is set correctly.
-    pub fn new(value: &'data [u8]) -> Result<MsgToUserTlv<'data>, TlvLvError> {
+    pub fn new(value: &'data [u8]) -> Result<MsgToUserTlv<'data>, TlvLvDataTooLargeError> {
         Ok(Self {
             tlv: Tlv::new(TlvType::MsgToUser, value)?,
         })
@@ -32,10 +37,12 @@ impl<'data> MsgToUserTlv<'data> {
         }
     }
 
+    #[inline]
     pub fn is_standard_tlv(&self) -> bool {
         true
     }
 
+    #[inline]
     pub fn tlv_type(&self) -> Option<TlvType> {
         Some(TlvType::MsgToUser)
     }
@@ -60,36 +67,65 @@ impl<'data> MsgToUserTlv<'data> {
         match msg_to_user.tlv.tlv_type_field() {
             TlvTypeField::Standard(tlv_type) => {
                 if tlv_type != TlvType::MsgToUser {
-                    return Err(TlvLvError::InvalidTlvTypeField {
+                    return Err(InvalidTlvTypeFieldError {
                         found: tlv_type as u8,
                         expected: Some(TlvType::MsgToUser as u8),
-                    });
+                    }
+                    .into());
                 }
             }
             TlvTypeField::Custom(raw) => {
-                return Err(TlvLvError::InvalidTlvTypeField {
+                return Err(InvalidTlvTypeFieldError {
                     found: raw,
                     expected: Some(TlvType::MsgToUser as u8),
-                });
+                }
+                .into());
             }
         }
         Ok(msg_to_user)
     }
-}
 
-impl WritableTlv for MsgToUserTlv<'_> {
+    #[inline]
+    pub fn to_tlv(&self) -> Tlv<'data> {
+        self.tlv
+    }
+
+    #[cfg(feature = "alloc")]
+    pub fn to_owned(&self) -> TlvOwned {
+        self.tlv.to_owned()
+    }
+
+    #[inline]
     fn len_written(&self) -> usize {
         self.len_full()
     }
 
     delegate!(
         to self.tlv {
-            fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
+            pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
         }
     );
 }
 
+impl<'a> From<MsgToUserTlv<'a>> for Tlv<'a> {
+    fn from(value: MsgToUserTlv<'a>) -> Tlv<'a> {
+        value.to_tlv()
+    }
+}
+
+impl WritableTlv for MsgToUserTlv<'_> {
+    #[inline]
+    fn len_written(&self) -> usize {
+        self.len_written()
+    }
+
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        self.tlv.write_to_bytes(buf)
+    }
+}
+
 impl GenericTlv for MsgToUserTlv<'_> {
+    #[inline]
     fn tlv_type_field(&self) -> TlvTypeField {
         self.tlv.tlv_type_field()
     }
@@ -139,6 +175,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_msg_to_user_type_reduction() {
+        let custom_value: [u8; 4] = [1, 2, 3, 4];
+        let msg_to_user = MsgToUserTlv::new(&custom_value).unwrap();
+        let tlv = msg_to_user.to_tlv();
+        assert_eq!(
+            tlv.tlv_type_field(),
+            TlvTypeField::Standard(TlvType::MsgToUser)
+        );
+
+        assert_eq!(tlv.value(), custom_value);
+    }
+
+    #[test]
+    fn test_msg_to_user_to_tlv() {
+        let custom_value: [u8; 4] = [1, 2, 3, 4];
+        let msg_to_user = MsgToUserTlv::new(&custom_value).unwrap();
+        let tlv: Tlv = msg_to_user.into();
+        assert_eq!(msg_to_user.to_tlv(), tlv);
+    }
+
+    #[test]
+    fn test_msg_to_user_owner_converter() {
+        let custom_value: [u8; 4] = [1, 2, 3, 4];
+        let msg_to_user = MsgToUserTlv::new(&custom_value).unwrap();
+        let tlv = msg_to_user.to_owned();
+        assert_eq!(
+            tlv.tlv_type_field(),
+            TlvTypeField::Standard(TlvType::MsgToUser)
+        );
+
+        assert_eq!(tlv.value(), custom_value);
+    }
+
     #[test]
     fn test_reserved_msg_deserialization() {
         let custom_value: [u8; 3] = [1, 2, 3];
@@ -154,9 +224,9 @@ mod tests {
     fn test_reserved_msg_deserialization_invalid_type() {
         let trash: [u8; 5] = [TlvType::FlowLabel as u8, 3, 1, 2, 3];
         let error = MsgToUserTlv::from_bytes(&trash).unwrap_err();
-        if let TlvLvError::InvalidTlvTypeField { found, expected } = error {
-            assert_eq!(found, TlvType::FlowLabel as u8);
-            assert_eq!(expected, Some(TlvType::MsgToUser as u8));
+        if let TlvLvError::InvalidTlvTypeField(inner) = error {
+            assert_eq!(inner.found, TlvType::FlowLabel as u8);
+            assert_eq!(inner.expected, Some(TlvType::MsgToUser as u8));
         } else {
             panic!("Wrong error type returned: {:?}", error);
         }

src/crc.rs

@@ -0,0 +1,11 @@
+/// CRC algorithm used by the PUS standard, the CCSDS TC standard and the CFDP standard, using
+/// a [crc::NoTable] as the CRC implementation.
+pub const CRC_CCITT_FALSE_NO_TABLE: crc::Crc<u16, crc::NoTable> =
+    crc::Crc::<u16, crc::NoTable>::new(&crc::CRC_16_IBM_3740);
+/// CRC algorithm used by the PUS standard, the CCSDS TC standard and the CFDP standard, using
+/// [crc::Table<1>] as the CRC implementation.
+pub const CRC_CCITT_FALSE: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_3740);
+/// CRC algorithm used by the PUS standard, the CCSDS TC standard and the CFDP standard, using
+/// a [crc::Table<16>] large table as the CRC implementation.
+pub const CRC_CCITT_FALSE_BIG_TABLE: crc::Crc<u16, crc::Table<16>> =
+    crc::Crc::<u16, crc::Table<16>>::new(&crc::CRC_16_IBM_3740);

src/ecss/mod.rs

@@ -3,28 +3,33 @@
 //!
 //! You can find the PUS telecommand types in the [tc] module and the the PUS telemetry
 //! types inside the [tm] module.
-use crate::{ByteConversionError, CcsdsPacket, CRC_CCITT_FALSE};
+use crate::{
+    crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE},
+    ByteConversionError, CcsdsPacket,
+};
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
-use core::fmt::{Debug, Display, Formatter};
+use arbitrary_int::u4;
+use core::fmt::Debug;
 use core::mem::size_of;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-#[cfg(feature = "std")]
-use std::error::Error;
 
 pub mod event;
 pub mod hk;
 pub mod scheduling;
 pub mod tc;
+pub mod tc_pus_a;
 pub mod tm;
+pub mod tm_pus_a;
 pub mod verification;
 
 pub type CrcType = u16;
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
 #[non_exhaustive]
 pub enum PusServiceId {
@@ -71,26 +76,27 @@ pub enum PusServiceId {
 }
 
 /// All PUS versions. Only PUS C is supported by this library.
-#[derive(PartialEq, Eq, Copy, Clone, Debug)]
+#[derive(PartialEq, Eq, Debug, num_enum::TryFromPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u4, exhaustive = false)]
+#[repr(u8)]
 #[non_exhaustive]
 pub enum PusVersion {
     EsaPus = 0,
     PusA = 1,
     PusC = 2,
-    Invalid = 0b1111,
 }
 
-impl TryFrom<u8> for PusVersion {
-    type Error = ();
+impl TryFrom<u4> for PusVersion {
+    type Error = u4;
 
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
+    fn try_from(value: u4) -> Result<Self, Self::Error> {
         match value {
-            x if x == PusVersion::EsaPus as u8 => Ok(PusVersion::EsaPus),
-            x if x == PusVersion::PusA as u8 => Ok(PusVersion::PusA),
-            x if x == PusVersion::PusC as u8 => Ok(PusVersion::PusC),
-            _ => Err(()),
+            x if x == PusVersion::EsaPus.raw_value() => Ok(PusVersion::EsaPus),
+            x if x == PusVersion::PusA.raw_value() => Ok(PusVersion::PusA),
+            x if x == PusVersion::PusC.raw_value() => Ok(PusVersion::PusC),
+            _ => Err(value),
         }
     }
 }
@@ -98,6 +104,7 @@ impl TryFrom<u8> for PusVersion {
 /// ECSS Packet Type Codes (PTC)s.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
 pub enum PacketTypeCodes {
     Boolean = 1,
@@ -119,6 +126,7 @@ pub type Ptc = PacketTypeCodes;
 /// ECSS Packet Field Codes (PFC)s for the unsigned [Ptc].
 #[derive(Debug, Copy, Clone, Eq, PartialEq, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
 pub enum PfcUnsigned {
     OneByte = 4,
@@ -136,6 +144,7 @@ pub enum PfcUnsigned {
 /// ECSS Packet Field Codes (PFC)s for the real (floating point) [Ptc].
 #[derive(Debug, Copy, Clone, Eq, PartialEq, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
 pub enum PfcReal {
     /// 4 octets simple precision format (IEEE)
@@ -148,62 +157,34 @@ pub enum PfcReal {
     DoubleMilStd = 4,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum PusError {
-    VersionNotSupported(PusVersion),
+    #[error("PUS version {0:?} not supported")]
+    VersionNotSupported(u4),
+    #[error("checksum verification for crc16 {0:#06x} failed")]
     ChecksumFailure(u16),
     /// CRC16 needs to be calculated first
-    CrcCalculationMissing,
-    ByteConversion(ByteConversionError),
-}
-
-impl Display for PusError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            PusError::VersionNotSupported(v) => {
-                write!(f, "PUS version {v:?} not supported")
-            }
-            PusError::ChecksumFailure(crc) => {
-                write!(f, "checksum verification for crc16 {crc:#06x} failed")
-            }
-            PusError::CrcCalculationMissing => {
-                write!(f, "crc16 was not calculated")
-            }
-            PusError::ByteConversion(e) => {
-                write!(f, "pus error: {e}")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for PusError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        if let PusError::ByteConversion(e) = self {
-            return Some(e);
-        }
-        None
-    }
-}
-
-impl From<ByteConversionError> for PusError {
-    fn from(e: ByteConversionError) -> Self {
-        PusError::ByteConversion(e)
-    }
+    //#[error("crc16 was not calculated")]
+    //CrcCalculationMissing,
+    #[error("pus error: {0}")]
+    ByteConversion(#[from] ByteConversionError),
 }
 
 /// Generic trait to describe common attributes for both PUS Telecommands (TC) and PUS Telemetry
 /// (TM) packets. All PUS packets are also a special type of [CcsdsPacket]s.
 pub trait PusPacket: CcsdsPacket {
-    const PUS_VERSION: PusVersion = PusVersion::PusC;
-
-    fn pus_version(&self) -> PusVersion;
+    fn pus_version(&self) -> Result<PusVersion, u4>;
     fn service(&self) -> u8;
     fn subservice(&self) -> u8;
     fn user_data(&self) -> &[u8];
-    fn crc16(&self) -> Option<u16>;
+    /// CRC-16-CCITT checksum.
+    fn checksum(&self) -> Option<u16>;
+    /// The presence of the CRC-16-CCITT checksum is optional.
+    fn has_checksum(&self) -> bool {
+        self.checksum().is_some()
+    }
 }
 
 pub(crate) fn crc_from_raw_data(raw_data: &[u8]) -> Result<u16, ByteConversionError> {
@@ -230,17 +211,22 @@ pub(crate) fn user_data_from_raw(
     current_idx: usize,
     total_len: usize,
     slice: &[u8],
+    has_checksum: bool,
 ) -> Result<&[u8], ByteConversionError> {
-    match current_idx {
-        _ if current_idx > total_len - 2 => Err(ByteConversionError::FromSliceTooSmall {
+    if has_checksum {
+        if current_idx > total_len - 2 {
+            return Err(ByteConversionError::FromSliceTooSmall {
                 found: total_len - 2,
                 expected: current_idx,
-        }),
-        _ => Ok(&slice[current_idx..total_len - 2]),
+            });
+        }
+        Ok(&slice[current_idx..total_len - 2])
+    } else {
+        Ok(&slice[current_idx..total_len])
     }
 }
 
-pub(crate) fn verify_crc16_ccitt_false_from_raw_to_pus_error(
+pub fn verify_crc16_ccitt_false_from_raw_to_pus_error(
     raw_data: &[u8],
     crc16: u16,
 ) -> Result<(), PusError> {
@@ -249,7 +235,17 @@ pub(crate) fn verify_crc16_ccitt_false_from_raw_to_pus_error(
         .ok_or(PusError::ChecksumFailure(crc16))
 }
 
-pub(crate) fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
+pub fn verify_crc16_ccitt_false_from_raw_to_pus_error_no_table(
+    raw_data: &[u8],
+    crc16: u16,
+) -> Result<(), PusError> {
+    verify_crc16_ccitt_false_from_raw_no_table(raw_data)
+        .then_some(())
+        .ok_or(PusError::ChecksumFailure(crc16))
+}
+
+/// Verify the CRC16 of a raw packet.
+pub fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
     let mut digest = CRC_CCITT_FALSE.digest();
     digest.update(raw_data);
     if digest.finalize() == 0 {
@@ -258,28 +254,23 @@ pub(crate) fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
     false
 }
 
-macro_rules! ccsds_impl {
-    () => {
-        delegate!(to self.sp_header {
-            #[inline]
-            fn ccsds_version(&self) -> u8;
-            #[inline]
-            fn packet_id(&self) -> crate::PacketId;
-            #[inline]
-            fn psc(&self) -> crate::PacketSequenceCtrl;
-            #[inline]
-            fn data_len(&self) -> u16;
-        });
+/// Verify the CRC16 of a raw packet, using the table-less implementation.
+pub fn verify_crc16_ccitt_false_from_raw_no_table(raw_data: &[u8]) -> bool {
+    let mut digest = CRC_CCITT_FALSE_NO_TABLE.digest();
+    digest.update(raw_data);
+    if digest.finalize() == 0 {
+        return true;
     }
+    false
 }
 
 macro_rules! sp_header_impls {
     () => {
         delegate!(to self.sp_header {
             #[inline]
-            pub fn set_apid(&mut self, apid: u16) -> bool;
+            pub fn set_apid(&mut self, apid: u11);
             #[inline]
-            pub fn set_seq_count(&mut self, seq_count: u16) -> bool;
+            pub fn set_seq_count(&mut self, seq_count: u14);
             #[inline]
             pub fn set_seq_flags(&mut self, seq_flag: SequenceFlags);
         });
@@ -287,7 +278,6 @@ macro_rules! sp_header_impls {
 }
 
 use crate::util::{GenericUnsignedByteField, ToBeBytes, UnsignedEnum};
-pub(crate) use ccsds_impl;
 pub(crate) use sp_header_impls;
 
 /// Generic trait for ECSS enumeration which consist of a PFC field denoting their bit length
@@ -381,8 +371,47 @@ generic_ecss_enum_typedefs_and_from_impls! {
 /// byte representation. This is especially useful for generic abstractions which depend only
 /// on the serialization of those packets.
 pub trait WritablePusPacket {
+    /// The length here also includes the CRC length.
     fn len_written(&self) -> usize;
-    fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError>;
+
+    /// Checksum generation is enabled for the packet.
+    fn has_checksum(&self) -> bool;
+
+    /// Writes the packet to the given slice without writing the CRC checksum.
+    ///
+    /// The returned size is the written size WITHOUT the CRC checksum.
+    /// If the checksum generation is disabled, this function is identical to the APIs which
+    /// generate a checksum.
+    fn write_to_bytes_no_checksum(&self, slice: &mut [u8]) -> Result<usize, PusError>;
+
+    /// First uses [Self::write_to_bytes_no_checksum] to write the packet to the given slice and
+    /// then uses the [CRC_CCITT_FALSE] to calculate the CRC and write it to the slice if the
+    /// packet is configured to include a checksum.
+    fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError> {
+        let mut curr_idx = self.write_to_bytes_no_checksum(slice)?;
+        if self.has_checksum() {
+            let mut digest = CRC_CCITT_FALSE.digest();
+            digest.update(&slice[0..curr_idx]);
+            slice[curr_idx..curr_idx + 2].copy_from_slice(&digest.finalize().to_be_bytes());
+            curr_idx += 2;
+        }
+        Ok(curr_idx)
+    }
+
+    /// First uses [Self::write_to_bytes_no_checksum] to write the packet to the given slice and then
+    /// uses the [CRC_CCITT_FALSE_NO_TABLE] to calculate the CRC and write it to the slice if
+    /// the paket is configured to include a checksum.
+    fn write_to_bytes_checksum_no_table(&self, slice: &mut [u8]) -> Result<usize, PusError> {
+        let mut curr_idx = self.write_to_bytes_no_checksum(slice)?;
+        if self.has_checksum() {
+            let mut digest = CRC_CCITT_FALSE_NO_TABLE.digest();
+            digest.update(&slice[0..curr_idx]);
+            slice[curr_idx..curr_idx + 2].copy_from_slice(&digest.finalize().to_be_bytes());
+            curr_idx += 2;
+        }
+        Ok(curr_idx)
+    }
+
     #[cfg(feature = "alloc")]
     fn to_vec(&self) -> Result<Vec<u8>, PusError> {
         // This is the correct way to do this. See
@@ -394,6 +423,25 @@ pub trait WritablePusPacket {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CreatorConfig {
+    /// Set the CCSDS data length field on construction.
+    pub set_ccsds_len: bool,
+    /// CRC-16-CCITT Checksum is present.
+    pub has_checksum: bool,
+}
+
+impl Default for CreatorConfig {
+    fn default() -> Self {
+        Self {
+            set_ccsds_len: true,
+            has_checksum: true,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloc::string::ToString;
@@ -521,9 +569,10 @@ mod tests {
 
     #[test]
     fn test_pus_error_display() {
-        let unsupport_version = PusError::VersionNotSupported(super::PusVersion::EsaPus);
+        let unsupport_version =
+            PusError::VersionNotSupported(super::PusVersion::EsaPus.raw_value());
         let write_str = unsupport_version.to_string();
-        assert_eq!(write_str, "PUS version EsaPus not supported")
+        assert_eq!(write_str, "PUS version 0 not supported")
     }
 
     #[test]
@@ -557,8 +606,8 @@ mod tests {
     #[test]
     fn test_pus_error_eq_impl() {
         assert_eq!(
-            PusError::VersionNotSupported(PusVersion::EsaPus),
-            PusError::VersionNotSupported(PusVersion::EsaPus)
+            PusError::VersionNotSupported(PusVersion::EsaPus.raw_value()),
+            PusError::VersionNotSupported(PusVersion::EsaPus.raw_value())
         );
     }
 

src/ecss/scheduling.rs

@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
 pub enum Subservice {
     // Core subservices
@@ -47,6 +48,7 @@ pub enum Subservice {
 
 /// This status applies to sub-schedules and groups as well as specified in ECSS-E-ST-70-41C 8.11.3
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum SchedStatus {
     Disabled = 0,
@@ -66,6 +68,7 @@ impl From<bool> for SchedStatus {
 
 /// Time window types as specified in  ECSS-E-ST-70-41C 8.11.3
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum TimeWindowType {
     SelectAll = 0,

src/ecss/verification.rs

@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Eq, PartialEq, Copy, Clone, IntoPrimitive, TryFromPrimitive)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
 pub enum Subservice {
     TmAcceptanceSuccess = 1,

src/seq_count.rs

@@ -0,0 +1,437 @@
+use crate::MAX_SEQ_COUNT;
+use arbitrary_int::traits::Integer;
+use core::cell::Cell;
+use paste::paste;
+
+/// Core trait for objects which can provide a sequence count.
+///
+/// The core functions are not mutable on purpose to allow easier usage with
+/// static structs when using the interior mutability pattern. This can be achieved by using
+/// [Cell], [core::cell::RefCell] or atomic types.
+pub trait SequenceCounter {
+    type Raw: Into<u64>;
+    const MAX_BIT_WIDTH: usize;
+
+    fn get(&self) -> Self::Raw;
+
+    fn increment(&self);
+
+    fn increment_mut(&mut self) {
+        self.increment();
+    }
+
+    fn get_and_increment(&self) -> Self::Raw {
+        let val = self.get();
+        self.increment();
+        val
+    }
+
+    fn get_and_increment_mut(&mut self) -> Self::Raw {
+        self.get_and_increment()
+    }
+}
+
+#[derive(Clone)]
+pub struct SequenceCounterSimple<T: Copy> {
+    seq_count: Cell<T>,
+    // The maximum value
+    max_val: T,
+}
+
+macro_rules! impl_for_primitives {
+    ($($ty: ident,)+) => {
+        $(
+            paste! {
+                impl SequenceCounterSimple<$ty> {
+                    pub fn [<new_custom_max_val_ $ty>](max_val: $ty) -> Self {
+                        Self {
+                            seq_count: Cell::new(0),
+                            max_val,
+                        }
+                    }
+                    pub fn [<new_ $ty>]() -> Self {
+                        Self {
+                            seq_count: Cell::new(0),
+                            max_val: $ty::MAX
+                        }
+                    }
+                }
+
+                impl Default for SequenceCounterSimple<$ty> {
+                    fn default() -> Self {
+                        Self::[<new_ $ty>]()
+                    }
+                }
+
+                impl SequenceCounter for SequenceCounterSimple<$ty> {
+                    type Raw = $ty;
+                    const MAX_BIT_WIDTH: usize = core::mem::size_of::<Self::Raw>() * 8;
+
+                    fn get(&self) -> Self::Raw {
+                        self.seq_count.get()
+                    }
+
+                    fn increment(&self) {
+                        self.get_and_increment();
+                    }
+
+                    fn get_and_increment(&self) -> Self::Raw {
+                        let curr_count = self.seq_count.get();
+
+                        if curr_count == self.max_val {
+                            self.seq_count.set(0);
+                        } else {
+                            self.seq_count.set(curr_count + 1);
+                        }
+                        curr_count
+                    }
+                }
+            }
+        )+
+    }
+}
+
+impl_for_primitives!(u8, u16, u32, u64,);
+
+/// This is a sequence count provider which wraps around at [MAX_SEQ_COUNT].
+#[derive(Clone)]
+pub struct SequenceCounterCcsdsSimple {
+    provider: SequenceCounterSimple<u16>,
+}
+
+impl Default for SequenceCounterCcsdsSimple {
+    fn default() -> Self {
+        Self {
+            provider: SequenceCounterSimple::new_custom_max_val_u16(MAX_SEQ_COUNT.as_u16()),
+        }
+    }
+}
+
+impl SequenceCounter for SequenceCounterCcsdsSimple {
+    type Raw = u16;
+    const MAX_BIT_WIDTH: usize = core::mem::size_of::<Self::Raw>() * 8;
+    delegate::delegate! {
+        to self.provider {
+            fn get(&self) -> u16;
+            fn increment(&self);
+            fn get_and_increment(&self) -> u16;
+        }
+    }
+}
+
+impl SequenceCounter for core::sync::atomic::AtomicU8 {
+    type Raw = u8;
+
+    const MAX_BIT_WIDTH: usize = 8;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl SequenceCounter for core::sync::atomic::AtomicU16 {
+    type Raw = u16;
+
+    const MAX_BIT_WIDTH: usize = 16;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl SequenceCounter for core::sync::atomic::AtomicU32 {
+    type Raw = u32;
+
+    const MAX_BIT_WIDTH: usize = 32;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+#[cfg(target_has_atomic = "64")]
+impl SequenceCounter for core::sync::atomic::AtomicU64 {
+    type Raw = u64;
+
+    const MAX_BIT_WIDTH: usize = 64;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl SequenceCounter for portable_atomic::AtomicU8 {
+    type Raw = u8;
+
+    const MAX_BIT_WIDTH: usize = 8;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl SequenceCounter for portable_atomic::AtomicU16 {
+    type Raw = u16;
+
+    const MAX_BIT_WIDTH: usize = 16;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl SequenceCounter for portable_atomic::AtomicU32 {
+    type Raw = u32;
+
+    const MAX_BIT_WIDTH: usize = 32;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl SequenceCounter for portable_atomic::AtomicU64 {
+    type Raw = u64;
+
+    const MAX_BIT_WIDTH: usize = 64;
+
+    fn get(&self) -> Self::Raw {
+        self.load(core::sync::atomic::Ordering::Relaxed)
+    }
+
+    fn increment(&self) {
+        self.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+impl<T: SequenceCounter + ?Sized> SequenceCounter for &T {
+    type Raw = T::Raw;
+    const MAX_BIT_WIDTH: usize = T::MAX_BIT_WIDTH;
+
+    fn get(&self) -> Self::Raw {
+        (**self).get()
+    }
+
+    fn increment(&self) {
+        (**self).increment()
+    }
+}
+
+macro_rules! sync_clonable_seq_counter_impl {
+    ($ty: ident) => {
+        paste::paste! {
+            /// This can be used if a custom wrap value is required when using a thread-safe
+            /// atomic based sequence counter.
+            #[derive(Debug)]
+            pub struct [<SequenceCounterSyncCustomWrap $ty:upper>] {
+                seq_count: core::sync::atomic::[<Atomic $ty:upper>],
+                max_val: $ty,
+            }
+
+            impl [<SequenceCounterSyncCustomWrap $ty:upper>] {
+                pub fn new(max_val: $ty) -> Self {
+                    Self {
+                        seq_count: core::sync::atomic::[<Atomic $ty:upper>]::new(0),
+                        max_val,
+                    }
+                }
+            }
+
+            impl SequenceCounter for [<SequenceCounterSyncCustomWrap $ty:upper>] {
+                type Raw = $ty;
+                const MAX_BIT_WIDTH: usize = core::mem::size_of::<Self::Raw>() * 8;
+
+                fn get(&self) -> $ty {
+                    self.seq_count.load(core::sync::atomic::Ordering::Relaxed)
+                }
+
+                fn increment(&self) {
+                    self.get_and_increment();
+                }
+
+                fn get_and_increment(&self) -> $ty {
+                    self.seq_count.fetch_update(
+                        core::sync::atomic::Ordering::Relaxed,
+                        core::sync::atomic::Ordering::Relaxed,
+                        |cur| {
+                            // compute the next value, wrapping at MAX_VAL
+                            let next = if cur == self.max_val { 0 } else { cur + 1 };
+                            Some(next)
+                        },
+                    ).unwrap()
+                }
+            }
+        }
+    };
+}
+
+#[cfg(target_has_atomic = "8")]
+sync_clonable_seq_counter_impl!(u8);
+#[cfg(target_has_atomic = "16")]
+sync_clonable_seq_counter_impl!(u16);
+#[cfg(target_has_atomic = "32")]
+sync_clonable_seq_counter_impl!(u32);
+#[cfg(target_has_atomic = "64")]
+sync_clonable_seq_counter_impl!(u64);
+
+#[cfg(test)]
+mod tests {
+    use core::sync::atomic::{AtomicU16, AtomicU32, AtomicU64, AtomicU8};
+
+    use crate::seq_count::{
+        SequenceCounter, SequenceCounterCcsdsSimple, SequenceCounterSimple,
+        SequenceCounterSyncCustomWrapU8,
+    };
+    use crate::MAX_SEQ_COUNT;
+
+    #[test]
+    fn test_u8_counter() {
+        let u8_counter = SequenceCounterSimple::<u8>::default();
+        assert_eq!(u8_counter.get(), 0);
+        assert_eq!(u8_counter.get_and_increment(), 0);
+        assert_eq!(u8_counter.get_and_increment(), 1);
+        assert_eq!(u8_counter.get(), 2);
+    }
+
+    #[test]
+    fn test_u8_counter_overflow() {
+        let u8_counter = SequenceCounterSimple::new_u8();
+        for _ in 0..256 {
+            u8_counter.increment();
+        }
+        assert_eq!(u8_counter.get(), 0);
+    }
+
+    #[test]
+    fn test_ccsds_counter() {
+        let ccsds_counter = SequenceCounterCcsdsSimple::default();
+        assert_eq!(ccsds_counter.get(), 0);
+        assert_eq!(ccsds_counter.get_and_increment(), 0);
+        assert_eq!(ccsds_counter.get_and_increment(), 1);
+        assert_eq!(ccsds_counter.get(), 2);
+    }
+
+    #[test]
+    fn test_ccsds_counter_overflow() {
+        let ccsds_counter = SequenceCounterCcsdsSimple::default();
+        for _ in 0..MAX_SEQ_COUNT.value() + 1 {
+            ccsds_counter.increment();
+        }
+        assert_eq!(ccsds_counter.get(), 0);
+    }
+
+    fn common_counter_test(seq_counter: &mut impl SequenceCounter) {
+        assert_eq!(seq_counter.get().into(), 0);
+        assert_eq!(seq_counter.get_and_increment().into(), 0);
+        assert_eq!(seq_counter.get_and_increment().into(), 1);
+        assert_eq!(seq_counter.get().into(), 2);
+        seq_counter.increment_mut();
+        assert_eq!(seq_counter.get().into(), 3);
+        assert_eq!(seq_counter.get_and_increment_mut().into(), 3);
+        assert_eq!(seq_counter.get().into(), 4);
+    }
+
+    #[test]
+    fn test_atomic_counter_u8() {
+        let mut sync_u8_counter = AtomicU8::new(0);
+        common_counter_test(&mut sync_u8_counter);
+    }
+
+    #[test]
+    fn test_atomic_counter_u16() {
+        let mut sync_u16_counter = AtomicU16::new(0);
+        common_counter_test(&mut sync_u16_counter);
+    }
+
+    #[test]
+    fn test_atomic_counter_u32() {
+        let mut sync_u32_counter = AtomicU32::new(0);
+        common_counter_test(&mut sync_u32_counter);
+    }
+
+    #[test]
+    fn test_atomic_counter_u64() {
+        let mut sync_u64_counter = AtomicU64::new(0);
+        common_counter_test(&mut sync_u64_counter);
+    }
+
+    #[test]
+    fn test_portable_atomic_counter_u8() {
+        let mut sync_u8_counter = portable_atomic::AtomicU8::new(0);
+        common_counter_test(&mut sync_u8_counter);
+    }
+
+    #[test]
+    fn test_portable_atomic_counter_u16() {
+        let mut sync_u16_counter = portable_atomic::AtomicU16::new(0);
+        common_counter_test(&mut sync_u16_counter);
+    }
+
+    #[test]
+    fn test_portable_atomic_counter_u32() {
+        let mut sync_u32_counter = portable_atomic::AtomicU32::new(0);
+        common_counter_test(&mut sync_u32_counter);
+    }
+
+    #[test]
+    fn test_portable_atomic_counter_u64() {
+        let mut sync_u64_counter = portable_atomic::AtomicU64::new(0);
+        common_counter_test(&mut sync_u64_counter);
+    }
+
+    fn common_overflow_test_u8(seq_counter: &impl SequenceCounter) {
+        for _ in 0..u8::MAX as u16 + 1 {
+            seq_counter.increment();
+        }
+        assert_eq!(seq_counter.get().into(), 0);
+    }
+
+    #[test]
+    fn test_atomic_u8_counter_overflow() {
+        let sync_u8_counter = AtomicU8::new(0);
+        common_overflow_test_u8(&sync_u8_counter);
+    }
+
+    #[test]
+    fn test_portable_atomic_u8_counter_overflow() {
+        let sync_u8_counter = portable_atomic::AtomicU8::new(0);
+        common_overflow_test_u8(&sync_u8_counter);
+    }
+
+    #[test]
+    fn test_atomic_ref_counters_overflow_custom_max_val() {
+        let sync_u8_counter = SequenceCounterSyncCustomWrapU8::new(128);
+        for _ in 0..129 {
+            sync_u8_counter.increment();
+        }
+        assert_eq!(sync_u8_counter.get(), 0);
+    }
+}

src/time/cds.rs

@@ -7,17 +7,13 @@
 use crate::private::Sealed;
 use crate::ByteConversionError;
 use core::cmp::Ordering;
-use core::fmt::{Debug, Display, Formatter};
+use core::fmt::Debug;
 use core::ops::{Add, AddAssign};
 use core::time::Duration;
 
-use delegate::delegate;
-
 #[cfg(feature = "std")]
 use super::StdTimestampError;
 #[cfg(feature = "std")]
-use std::error::Error;
-#[cfg(feature = "std")]
 use std::time::{SystemTime, SystemTimeError};
 
 #[cfg(feature = "chrono")]
@@ -86,6 +82,7 @@ pub enum LengthOfDaySegment {
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum SubmillisPrecision {
     Absent = 0b00,
     Microseconds = 0b01,
@@ -93,49 +90,19 @@ pub enum SubmillisPrecision {
     Reserved = 0b11,
 }
 
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum CdsError {
     /// CCSDS days value exceeds maximum allowed size or is negative
+    #[error("invalid ccsds days {0}")]
     InvalidCcsdsDays(i64),
     /// There are distinct constructors depending on the days field width detected in the preamble
     /// field. This error will be returned if there is a missmatch.
+    #[error("wrong constructor for length of day {0:?} detected in preamble")]
     InvalidCtorForDaysOfLenInPreamble(LengthOfDaySegment),
-    DateBeforeCcsdsEpoch(DateBeforeCcsdsEpochError),
-}
-
-impl Display for CdsError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            CdsError::InvalidCcsdsDays(days) => {
-                write!(f, "invalid ccsds days {days}")
-            }
-            CdsError::InvalidCtorForDaysOfLenInPreamble(length_of_day) => {
-                write!(
-                    f,
-                    "wrong constructor for length of day {length_of_day:?} detected in preamble",
-                )
-            }
-            CdsError::DateBeforeCcsdsEpoch(e) => write!(f, "date before CCSDS epoch: {e}"),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for CdsError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            CdsError::DateBeforeCcsdsEpoch(e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-impl From<DateBeforeCcsdsEpochError> for CdsError {
-    fn from(value: DateBeforeCcsdsEpochError) -> Self {
-        Self::DateBeforeCcsdsEpoch(value)
-    }
+    #[error("date before CCSDS epoch: {0}")]
+    DateBeforeCcsdsEpoch(#[from] DateBeforeCcsdsEpochError),
 }
 
 pub fn length_of_day_segment_from_pfield(pfield: u8) -> LengthOfDaySegment {
@@ -300,20 +267,23 @@ impl CdsConverter for ConversionFromUnix {
         self.unix_days_seconds
     }
 }
+
 /// Helper struct which generates fields for the CDS time provider from a datetime.
+#[cfg(feature = "chrono")]
 struct ConversionFromChronoDatetime {
     unix_conversion: ConversionFromUnix,
     submillis_prec: SubmillisPrecision,
     submillis: u32,
 }
 
+#[cfg(feature = "chrono")]
 impl CdsCommon for ConversionFromChronoDatetime {
     #[inline]
     fn submillis_precision(&self) -> SubmillisPrecision {
         self.submillis_prec
     }
 
-    delegate! {
+    delegate::delegate! {
         to self.unix_conversion {
             #[inline]
             fn ms_of_day(&self) -> u32;
@@ -328,8 +298,9 @@ impl CdsCommon for ConversionFromChronoDatetime {
     }
 }
 
+#[cfg(feature = "chrono")]
 impl CdsConverter for ConversionFromChronoDatetime {
-    delegate! {to self.unix_conversion {
+    delegate::delegate! {to self.unix_conversion {
         #[inline]
         fn unix_days_seconds(&self) -> i64;
     }}
@@ -366,7 +337,6 @@ impl ConversionFromChronoDatetime {
         Self::new_generic(dt, SubmillisPrecision::Picoseconds)
     }
 
-    #[cfg(feature = "chrono")]
     fn new_generic(
         dt: &chrono::DateTime<chrono::Utc>,
         prec: SubmillisPrecision,
@@ -448,7 +418,7 @@ impl CdsCommon for ConversionFromNow {
     fn submillis_precision(&self) -> SubmillisPrecision {
         self.submillis_prec
     }
-    delegate! {
+    delegate::delegate! {
         to self.unix_conversion {
             fn ms_of_day(&self) -> u32;
             fn ccsds_days_as_u32(&self) -> u32;
@@ -462,7 +432,7 @@ impl CdsCommon for ConversionFromNow {
 
 #[cfg(feature = "std")]
 impl CdsConverter for ConversionFromNow {
-    delegate! {to self.unix_conversion { fn unix_days_seconds(&self) -> i64; }}
+    delegate::delegate! {to self.unix_conversion { fn unix_days_seconds(&self) -> i64; }}
 }
 
 #[cfg(feature = "alloc")]
@@ -600,7 +570,7 @@ impl<ProvidesDaysLen: ProvidesDaysLength> CdsTime<ProvidesDaysLen> {
             ));
         }
         let pfield = buf[0];
-        match CcsdsTimeCode::try_from(pfield >> 4 & 0b111) {
+        match CcsdsTimeCode::try_from((pfield >> 4) & 0b111) {
             Ok(cds_type) => match cds_type {
                 CcsdsTimeCode::Cds => (),
                 _ => {
@@ -613,7 +583,7 @@ impl<ProvidesDaysLen: ProvidesDaysLength> CdsTime<ProvidesDaysLen> {
             _ => {
                 return Err(TimestampError::InvalidTimeCode {
                     expected: CcsdsTimeCode::Cds,
-                    found: pfield >> 4 & 0b111,
+                    found: (pfield >> 4) & 0b111,
                 });
             }
         };
@@ -672,14 +642,12 @@ impl<ProvidesDaysLen: ProvidesDaysLength> CdsTime<ProvidesDaysLen> {
         self.unix_time = UnixTime::new(unix_days_seconds, subsec_nanos);
     }
 
-    fn length_check(&self, buf: &[u8], len_as_bytes: usize) -> Result<(), TimestampError> {
+    fn length_check(&self, buf: &[u8], len_as_bytes: usize) -> Result<(), ByteConversionError> {
         if buf.len() < len_as_bytes {
-            return Err(TimestampError::ByteConversion(
-                ByteConversionError::ToSliceTooSmall {
+            return Err(ByteConversionError::ToSliceTooSmall {
                 expected: len_as_bytes,
                 found: buf.len(),
-                },
-            ));
+            });
         }
         Ok(())
     }
@@ -987,6 +955,23 @@ impl CdsTime<DaysLen16Bits> {
         Self::from_now_generic_ps_prec(LengthOfDaySegment::Short16Bits)
     }
 
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        self.length_check(buf, self.len_as_bytes())?;
+        buf[0] = self.pfield;
+        buf[1..3].copy_from_slice(self.ccsds_days.to_be_bytes().as_slice());
+        buf[3..7].copy_from_slice(self.ms_of_day.to_be_bytes().as_slice());
+        match self.submillis_precision() {
+            SubmillisPrecision::Microseconds => {
+                buf[7..9].copy_from_slice((self.submillis() as u16).to_be_bytes().as_slice());
+            }
+            SubmillisPrecision::Picoseconds => {
+                buf[7..11].copy_from_slice(self.submillis().to_be_bytes().as_slice());
+            }
+            _ => (),
+        }
+        Ok(self.len_as_bytes())
+    }
+
     pub fn from_bytes_with_u16_days(buf: &[u8]) -> Result<Self, TimestampError> {
         let submillis_precision =
             Self::generic_raw_read_checks(buf, LengthOfDaySegment::Short16Bits)?;
@@ -1242,20 +1227,7 @@ impl TimeReader for CdsTime<DaysLen24Bits> {
 
 impl TimeWriter for CdsTime<DaysLen16Bits> {
     fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, TimestampError> {
-        self.length_check(buf, self.len_as_bytes())?;
-        buf[0] = self.pfield;
-        buf[1..3].copy_from_slice(self.ccsds_days.to_be_bytes().as_slice());
-        buf[3..7].copy_from_slice(self.ms_of_day.to_be_bytes().as_slice());
-        match self.submillis_precision() {
-            SubmillisPrecision::Microseconds => {
-                buf[7..9].copy_from_slice((self.submillis() as u16).to_be_bytes().as_slice());
-            }
-            SubmillisPrecision::Picoseconds => {
-                buf[7..11].copy_from_slice(self.submillis().to_be_bytes().as_slice());
-            }
-            _ => (),
-        }
-        Ok(self.len_as_bytes())
+        self.write_to_bytes(buf).map_err(TimestampError::from)
     }
 
     fn len_written(&self) -> usize {
@@ -1263,8 +1235,8 @@ impl TimeWriter for CdsTime<DaysLen16Bits> {
     }
 }
 
-impl TimeWriter for CdsTime<DaysLen24Bits> {
-    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, TimestampError> {
+impl CdsTime<DaysLen24Bits> {
+    pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         self.length_check(buf, self.len_as_bytes())?;
         buf[0] = self.pfield;
         let be_days = self.ccsds_days.to_be_bytes();
@@ -1281,6 +1253,12 @@ impl TimeWriter for CdsTime<DaysLen24Bits> {
         }
         Ok(self.len_as_bytes())
     }
+}
+
+impl TimeWriter for CdsTime<DaysLen24Bits> {
+    fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, TimestampError> {
+        self.write_to_bytes(buf).map_err(TimestampError::from)
+    }
 
     fn len_written(&self) -> usize {
         self.len_as_bytes()
@@ -1361,7 +1339,7 @@ mod tests {
     use super::*;
     use crate::time::TimestampError::{ByteConversion, InvalidTimeCode};
     use crate::time::{UnixTime, DAYS_CCSDS_TO_UNIX, MS_PER_DAY};
-    use crate::ByteConversionError::{FromSliceTooSmall, ToSliceTooSmall};
+    use crate::ByteConversionError::FromSliceTooSmall;
     use alloc::string::ToString;
     use chrono::{Datelike, NaiveDate, Timelike};
     #[cfg(feature = "serde")]
@@ -1516,12 +1494,14 @@ mod tests {
             assert!(res.is_err());
             let error = res.unwrap_err();
             match error {
-                ByteConversion(ToSliceTooSmall { found, expected }) => {
+                ByteConversionError::ToSliceTooSmall { found, expected } => {
                     assert_eq!(found, i);
                     assert_eq!(expected, 7);
                     assert_eq!(
                         error.to_string(),
-                        format!("time stamp: target slice with size {i} is too small, expected size of at least 7")
+                        format!(
+                            "target slice with size {i} is too small, expected size of at least 7"
+                        )
                     );
                 }
                 _ => panic!(
@@ -1567,10 +1547,7 @@ mod tests {
         if let InvalidTimeCode { expected, found } = err {
             assert_eq!(expected, CcsdsTimeCode::Cds);
             assert_eq!(found, 0);
-            assert_eq!(
-                err.to_string(),
-                "invalid raw time code value 0 for time code Cds"
-            );
+            assert_eq!(err.to_string(), "invalid time code, expected Cds, found 0");
         }
     }
 
@@ -2331,7 +2308,7 @@ mod tests {
     fn test_serialization() {
         let stamp_now = CdsTime::now_with_u16_days().expect("Error retrieving time");
         let val = to_allocvec(&stamp_now).expect("Serializing timestamp failed");
-        assert!(val.len() > 0);
+        assert!(!val.is_empty());
         let stamp_deser: CdsTime = from_bytes(&val).expect("Stamp deserialization failed");
         assert_eq!(stamp_deser, stamp_now);
     }

src/time/cuc.rs

@@ -6,10 +6,9 @@
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use core::fmt::{Debug, Display, Formatter};
+use core::fmt::Debug;
 use core::ops::{Add, AddAssign};
 use core::time::Duration;
-use core::u64;
 
 use crate::ByteConversionError;
 
@@ -21,8 +20,6 @@ use super::{
     TimestampError, UnixTime,
 };
 #[cfg(feature = "std")]
-use std::error::Error;
-#[cfg(feature = "std")]
 use std::time::SystemTime;
 
 #[cfg(feature = "chrono")]
@@ -104,63 +101,24 @@ pub fn fractional_part_from_subsec_ns(res: FractionalResolution, ns: u64) -> Fra
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum CucError {
+    #[error("invalid cuc counter byte width {0}")]
     InvalidCounterWidth(u8),
     /// Invalid counter supplied.
-    InvalidCounter {
-        width: u8,
-        counter: u64,
-    },
+    #[error("invalid cuc counter {counter} for width {width}")]
+    InvalidCounter { width: u8, counter: u64 },
+    #[error("invalid cuc fractional part {value} for resolution {resolution:?}")]
     InvalidFractions {
         resolution: FractionalResolution,
         value: u64,
     },
+    #[error("error while correcting for leap seconds")]
     LeapSecondCorrectionError,
-    DateBeforeCcsdsEpoch(DateBeforeCcsdsEpochError),
-}
-
-impl Display for CucError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            CucError::InvalidCounterWidth(w) => {
-                write!(f, "invalid cuc counter byte width {w}")
-            }
-            CucError::InvalidCounter { width, counter } => {
-                write!(f, "invalid cuc counter {counter} for width {width}")
-            }
-            CucError::InvalidFractions { resolution, value } => {
-                write!(
-                    f,
-                    "invalid cuc fractional part {value} for resolution {resolution:?}"
-                )
-            }
-            CucError::LeapSecondCorrectionError => {
-                write!(f, "error while correcting for leap seconds")
-            }
-            CucError::DateBeforeCcsdsEpoch(e) => {
-                write!(f, "date before ccsds epoch: {e}")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for CucError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            CucError::DateBeforeCcsdsEpoch(e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-impl From<DateBeforeCcsdsEpochError> for CucError {
-    fn from(e: DateBeforeCcsdsEpochError) -> Self {
-        Self::DateBeforeCcsdsEpoch(e)
-    }
+    #[error("date before ccsds epoch: {0}")]
+    DateBeforeCcsdsEpoch(#[from] DateBeforeCcsdsEpochError),
 }
 
 /// Tuple object where the first value is the width of the counter and the second value

src/time/mod.rs

@@ -3,10 +3,8 @@ use crate::ByteConversionError;
 #[cfg(feature = "chrono")]
 use chrono::{TimeZone, Utc};
 use core::cmp::Ordering;
-use core::fmt::{Display, Formatter};
 use core::ops::{Add, AddAssign, Sub};
 use core::time::Duration;
-use core::u8;
 
 #[allow(unused_imports)]
 #[cfg(not(feature = "std"))]
@@ -15,8 +13,6 @@ use num_traits::float::FloatCore;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-#[cfg(feature = "std")]
-use std::error::Error;
 #[cfg(feature = "std")]
 use std::time::{SystemTime, SystemTimeError};
 #[cfg(feature = "std")]
@@ -64,81 +60,29 @@ pub fn ccsds_time_code_from_p_field(pfield: u8) -> Result<CcsdsTimeCode, u8> {
     CcsdsTimeCode::try_from(raw_bits).map_err(|_| raw_bits)
 }
 
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[error("date before ccsds epoch: {0:?}")]
 pub struct DateBeforeCcsdsEpochError(UnixTime);
 
-impl Display for DateBeforeCcsdsEpochError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        write!(f, "date before ccsds epoch: {:?}", self.0)
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for DateBeforeCcsdsEpochError {}
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[non_exhaustive]
 pub enum TimestampError {
+    #[error("invalid time code, expected {expected:?}, found {found}")]
     InvalidTimeCode { expected: CcsdsTimeCode, found: u8 },
-    ByteConversion(ByteConversionError),
-    Cds(cds::CdsError),
-    Cuc(cuc::CucError),
+    #[error("time stamp: byte conversion error: {0}")]
+    ByteConversion(#[from] ByteConversionError),
+    #[error("CDS error: {0}")]
+    Cds(#[from] cds::CdsError),
+    #[error("CUC error: {0}")]
+    Cuc(#[from] cuc::CucError),
+    #[error("custom epoch not supported")]
     CustomEpochNotSupported,
 }
 
-impl Display for TimestampError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            TimestampError::InvalidTimeCode { expected, found } => {
-                write!(
-                    f,
-                    "invalid raw time code value {found} for time code {expected:?}"
-                )
-            }
-            TimestampError::Cds(e) => {
-                write!(f, "cds error: {e}")
-            }
-            TimestampError::Cuc(e) => {
-                write!(f, "cuc error: {e}")
-            }
-            TimestampError::ByteConversion(e) => {
-                write!(f, "time stamp: {e}")
-            }
-            TimestampError::CustomEpochNotSupported => {
-                write!(f, "custom epochs are not supported")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for TimestampError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            TimestampError::ByteConversion(e) => Some(e),
-            TimestampError::Cds(e) => Some(e),
-            TimestampError::Cuc(e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-impl From<cds::CdsError> for TimestampError {
-    fn from(e: cds::CdsError) -> Self {
-        TimestampError::Cds(e)
-    }
-}
-
-impl From<cuc::CucError> for TimestampError {
-    fn from(e: cuc::CucError) -> Self {
-        TimestampError::Cuc(e)
-    }
-}
-
 #[cfg(feature = "std")]
 pub mod std_mod {
     use crate::time::TimestampError;
@@ -744,7 +688,7 @@ mod tests {
     fn test_cuc_error_printout() {
         let cuc_error = CucError::InvalidCounterWidth(12);
         let stamp_error = TimestampError::from(cuc_error);
-        assert_eq!(stamp_error.to_string(), format!("cuc error: {cuc_error}"));
+        assert_eq!(stamp_error.to_string(), format!("CUC error: {cuc_error}"));
     }
 
     #[test]

src/uslp/mod.rs

@@ -0,0 +1,948 @@
+/// # Support of the CCSDS Unified Space Data Link Protocol (USLP)
+use crate::{crc::CRC_CCITT_FALSE, ByteConversionError};
+
+/// Only this version is supported by the library
+pub const USLP_VERSION_NUMBER: u8 = 0b1100;
+
+/// Identifies the association of the data contained in the transfer frame.
+#[derive(Debug, PartialEq, Eq, num_enum::TryFromPrimitive, num_enum::IntoPrimitive)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
+#[repr(u8)]
+pub enum SourceOrDestField {
+    /// SCID refers to the source of the transfer frame.
+    Source = 0,
+    /// SCID refers to the destination of the transfer frame.
+    Dest = 1,
+}
+
+#[derive(Debug, PartialEq, Eq, num_enum::TryFromPrimitive, num_enum::IntoPrimitive)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u1, exhaustive = true)]
+#[repr(u8)]
+pub enum BypassSequenceControlFlag {
+    /// Acceptance of this frame on the receiving end is subject to normal frame acceptance
+    /// checks of FARM.
+    SequenceControlledQoS = 0,
+    /// Frame Acceptance Checks of FARM by the receiving end shall be bypassed.
+    ExpeditedQoS = 1,
+}
+
+#[derive(
+    Debug, Copy, Clone, PartialEq, Eq, num_enum::TryFromPrimitive, num_enum::IntoPrimitive,
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[repr(u8)]
+pub enum ProtocolControlCommandFlag {
+    TfdfContainsUserData = 0,
+    TfdfContainsProtocolInfo = 1,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum UslpError {
+    #[error("byte conversion error: {0}")]
+    ByteConversion(#[from] ByteConversionError),
+    #[error("header is truncated, which is not supported")]
+    HeaderIsTruncated,
+    #[error("invalid protocol id: {0}")]
+    InvalidProtocolId(u8),
+    #[error("invalid construction rule: {0}")]
+    InvalidConstructionRule(u8),
+    #[error("invalid version number: {0}")]
+    InvalidVersionNumber(u8),
+    #[error("invalid virtual channel ID: {0}")]
+    InvalidVcId(u8),
+    #[error("invalid MAP ID: {0}")]
+    InvalidMapId(u8),
+    #[error("checksum failure")]
+    ChecksumFailure(u16),
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct InvalidValueForLen {
+    value: u64,
+    len: u8,
+}
+
+#[derive(Debug, Copy, Clone, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct PrimaryHeader {
+    pub spacecraft_id: u16,
+    pub source_or_dest_field: SourceOrDestField,
+    pub vc_id: u8,
+    pub map_id: u8,
+    frame_len_field: u16,
+    pub sequence_control_flag: BypassSequenceControlFlag,
+    pub protocol_control_command_flag: ProtocolControlCommandFlag,
+    pub ocf_flag: bool,
+    vc_frame_count_len: u8,
+    vc_frame_count: u64,
+}
+
+impl PrimaryHeader {
+    pub fn new(
+        spacecraft_id: u16,
+        source_or_dest_field: SourceOrDestField,
+        vc_id: u8,
+        map_id: u8,
+        frame_len: u16,
+    ) -> Result<Self, UslpError> {
+        if vc_id > 0b111111 {
+            return Err(UslpError::InvalidVcId(vc_id));
+        }
+        if map_id > 0b1111 {
+            return Err(UslpError::InvalidMapId(map_id));
+        }
+        Ok(Self {
+            spacecraft_id,
+            source_or_dest_field,
+            vc_id,
+            map_id,
+            frame_len_field: frame_len.saturating_sub(1),
+            sequence_control_flag: BypassSequenceControlFlag::SequenceControlledQoS,
+            protocol_control_command_flag: ProtocolControlCommandFlag::TfdfContainsUserData,
+            ocf_flag: false,
+            vc_frame_count_len: 0,
+            vc_frame_count: 0,
+        })
+    }
+
+    pub fn set_vc_frame_count(
+        &mut self,
+        count_len: u8,
+        count: u64,
+    ) -> Result<(), InvalidValueForLen> {
+        if count > 2_u64.pow(count_len as u32 * 8) - 1 {
+            return Err(InvalidValueForLen {
+                value: count,
+                len: count_len,
+            });
+        }
+        self.vc_frame_count_len = count_len;
+        self.vc_frame_count = count;
+        Ok(())
+    }
+
+    #[inline]
+    pub fn vc_frame_count(&self) -> u64 {
+        self.vc_frame_count
+    }
+
+    #[inline]
+    pub fn vc_frame_count_len(&self) -> u8 {
+        self.vc_frame_count_len
+    }
+
+    pub fn from_bytes(buf: &[u8]) -> Result<Self, UslpError> {
+        if buf.len() < 4 {
+            return Err(ByteConversionError::FromSliceTooSmall {
+                found: buf.len(),
+                expected: 4,
+            }
+            .into());
+        }
+        // Can only deal with regular frames for now.
+        if (buf[3] & 0b1) == 1 {
+            return Err(UslpError::HeaderIsTruncated);
+        }
+        // We could check this above, but this is a better error for the case where the user
+        // tries to read a truncated frame.
+        if buf.len() < 7 {
+            return Err(ByteConversionError::FromSliceTooSmall {
+                found: buf.len(),
+                expected: 7,
+            }
+            .into());
+        }
+        let version_number = (buf[0] >> 4) & 0b1111;
+        if version_number != USLP_VERSION_NUMBER {
+            return Err(UslpError::InvalidVersionNumber(version_number));
+        }
+        let source_or_dest_field = match (buf[2] >> 3) & 1 {
+            0 => SourceOrDestField::Source,
+            1 => SourceOrDestField::Dest,
+            _ => unreachable!(),
+        };
+        let vc_frame_count_len = buf[6] & 0b111;
+        if buf.len() < 7 + vc_frame_count_len as usize {
+            return Err(ByteConversionError::FromSliceTooSmall {
+                found: buf.len(),
+                expected: 7 + vc_frame_count_len as usize,
+            }
+            .into());
+        }
+        let vc_frame_count = match vc_frame_count_len {
+            1 => buf[7] as u64,
+            2 => u16::from_be_bytes(buf[7..9].try_into().unwrap()) as u64,
+            4 => u32::from_be_bytes(buf[7..11].try_into().unwrap()) as u64,
+            len => {
+                let mut vcf_count = 0u64;
+                let mut end = len;
+                for byte in buf[7..7 + len as usize].iter() {
+                    vcf_count |= (*byte as u64) << ((end - 1) * 8);
+                    end -= 1;
+                }
+                vcf_count
+            }
+        };
+        Ok(Self {
+            spacecraft_id: (((buf[0] as u16) & 0b1111) << 12)
+                | ((buf[1] as u16) << 4)
+                | ((buf[2] as u16) >> 4) & 0b1111,
+            source_or_dest_field,
+            vc_id: ((buf[2] & 0b111) << 3) | (buf[3] >> 5) & 0b111,
+            map_id: (buf[3] >> 1) & 0b1111,
+            frame_len_field: ((buf[4] as u16) << 8) | buf[5] as u16,
+            sequence_control_flag: ((buf[6] >> 7) & 0b1).try_into().unwrap(),
+            protocol_control_command_flag: ((buf[6] >> 6) & 0b1).try_into().unwrap(),
+            ocf_flag: ((buf[6] >> 3) & 0b1) != 0,
+            vc_frame_count_len,
+            vc_frame_count,
+        })
+    }
+
+    pub fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
+        if buf.len() < self.len_header() {
+            return Err(ByteConversionError::ToSliceTooSmall {
+                found: buf.len(),
+                expected: self.len_header(),
+            });
+        }
+        buf[0] = (USLP_VERSION_NUMBER << 4) | ((self.spacecraft_id >> 12) as u8) & 0b1111;
+        buf[1] = (self.spacecraft_id >> 4) as u8;
+        buf[2] = (((self.spacecraft_id & 0b1111) as u8) << 4)
+            | ((self.source_or_dest_field as u8) << 3)
+            | (self.vc_id >> 3) & 0b111;
+        buf[3] = ((self.vc_id & 0b111) << 5) | (self.map_id << 1);
+        buf[4..6].copy_from_slice(&self.frame_len_field.to_be_bytes());
+        buf[6] = ((self.sequence_control_flag as u8) << 7)
+            | ((self.protocol_control_command_flag as u8) << 6)
+            | ((self.ocf_flag as u8) << 3)
+            | self.vc_frame_count_len;
+        let mut packet_idx = 7;
+        for idx in (0..self.vc_frame_count_len).rev() {
+            buf[packet_idx] = ((self.vc_frame_count >> (idx * 8)) & 0xff) as u8;
+            packet_idx += 1;
+        }
+        Ok(self.len_header())
+    }
+
+    #[inline(always)]
+    pub fn set_frame_len(&mut self, frame_len: usize) {
+        // 4.1.2.7.2
+        // The field contains a length count C that equals one fewer than the total octets
+        // in the transfer frame.
+        self.frame_len_field = frame_len.saturating_sub(1) as u16;
+    }
+
+    #[inline(always)]
+    pub fn len_header(&self) -> usize {
+        7 + self.vc_frame_count_len as usize
+    }
+
+    #[inline(always)]
+    pub fn len_frame(&self) -> usize {
+        // 4.1.2.7.2
+        // The field contains a length count C that equals one fewer than the total octets
+        // in the transfer frame.
+        self.frame_len_field as usize + 1
+    }
+}
+
+/// Custom implementation which skips the check whether the VC frame count length field is equal.
+/// Only the actual VC count value is compared.
+impl PartialEq for PrimaryHeader {
+    fn eq(&self, other: &Self) -> bool {
+        self.spacecraft_id == other.spacecraft_id
+            && self.source_or_dest_field == other.source_or_dest_field
+            && self.vc_id == other.vc_id
+            && self.map_id == other.map_id
+            && self.frame_len_field == other.frame_len_field
+            && self.sequence_control_flag == other.sequence_control_flag
+            && self.protocol_control_command_flag == other.protocol_control_command_flag
+            && self.ocf_flag == other.ocf_flag
+            && self.vc_frame_count == other.vc_frame_count
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, num_enum::TryFromPrimitive, num_enum::IntoPrimitive)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u5, exhaustive = false)]
+#[repr(u8)]
+#[non_exhaustive]
+pub enum UslpProtocolId {
+    SpacePacketsOrEncapsulation = 0b00000,
+    /// COP-1 control commands within the TFDZ.
+    Cop1ControlCommands = 0b00001,
+    /// COP-P control commands within the TFDZ.
+    CopPControlCommands = 0b00010,
+    /// SDLS control commands within the TFDZ.
+    Sdls = 0b00011,
+    UserDefinedOctetStream = 0b00100,
+    /// Proximity-1 Supervisory Protocol Data Units (SPDUs) within the TFDZ.
+    Spdu = 0b00111,
+    /// Entire fixed-length TFDZ contains idle data.
+    Idle = 0b11111,
+}
+
+#[derive(Debug, PartialEq, Eq, num_enum::TryFromPrimitive, num_enum::IntoPrimitive)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[bitbybit::bitenum(u3, exhaustive = true)]
+#[repr(u8)]
+pub enum ConstructionRule {
+    /// Indicated fixed-length TFDZ whose contents are CCSDS packets concatenated together, which
+    /// span transfer frame boundaries. The First Header Pointer (FHP) is required for packet
+    /// extraction.
+    PacketSpanningMultipleFrames = 0b000,
+    StartOfMapaSduOrVcaSdu = 0b001,
+    ContinuingPortionOfMapaSdu = 0b010,
+    OctetStream = 0b011,
+    StartingSegment = 0b100,
+    ContinuingSegment = 0b101,
+    LastSegment = 0b110,
+    NoSegmentation = 0b111,
+}
+
+impl ConstructionRule {
+    pub const fn applicable_to_fixed_len_tfdz(&self) -> bool {
+        match self {
+            ConstructionRule::PacketSpanningMultipleFrames => true,
+            ConstructionRule::StartOfMapaSduOrVcaSdu => true,
+            ConstructionRule::ContinuingPortionOfMapaSdu => true,
+            ConstructionRule::OctetStream => false,
+            ConstructionRule::StartingSegment => false,
+            ConstructionRule::ContinuingSegment => false,
+            ConstructionRule::LastSegment => false,
+            ConstructionRule::NoSegmentation => false,
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct TransferFrameDataFieldHeader {
+    /// Construction rule for the TFDZ.
+    construction_rule: ConstructionRule,
+    uslp_protocol_id: UslpProtocolId,
+    /// First header or last valid octet pointer. Only present if the constuction rule indicated
+    /// a fixed-length TFDZ.
+    fhp_or_lvo: Option<u16>,
+}
+
+impl TransferFrameDataFieldHeader {
+    #[inline]
+    pub const fn len_header(&self) -> usize {
+        if self.construction_rule.applicable_to_fixed_len_tfdz() {
+            3
+        } else {
+            1
+        }
+    }
+
+    #[inline]
+    pub const fn construction_rule(&self) -> ConstructionRule {
+        self.construction_rule
+    }
+
+    #[inline]
+    pub const fn uslp_protocol_id(&self) -> UslpProtocolId {
+        self.uslp_protocol_id
+    }
+
+    #[inline]
+    pub const fn fhp_or_lvo(&self) -> Option<u16> {
+        self.fhp_or_lvo
+    }
+
+    pub fn from_bytes(buf: &[u8]) -> Result<Self, UslpError> {
+        if buf.is_empty() {
+            return Err(ByteConversionError::FromSliceTooSmall {
+                found: 0,
+                expected: 1,
+            }
+            .into());
+        }
+        let construction_rule = ConstructionRule::try_from((buf[0] >> 5) & 0b111)
+            .map_err(|e| UslpError::InvalidConstructionRule(e.number))?;
+        let mut fhp_or_lvo = None;
+        if construction_rule.applicable_to_fixed_len_tfdz() {
+            if buf.len() < 3 {
+                return Err(ByteConversionError::FromSliceTooSmall {
+                    found: buf.len(),
+                    expected: 3,
+                }
+                .into());
+            }
+            fhp_or_lvo = Some(u16::from_be_bytes(buf[1..3].try_into().unwrap()));
+        }
+        Ok(Self {
+            construction_rule,
+            uslp_protocol_id: UslpProtocolId::try_from(buf[0] & 0b11111)
+                .map_err(|e| UslpError::InvalidProtocolId(e.number))?,
+            fhp_or_lvo,
+        })
+    }
+}
+
+/// Simple USLP transfer frame reader.
+///
+/// Currently, only insert zone lengths of 0 are supported.
+#[derive(Debug)]
+pub struct TransferFrameReader<'buf> {
+    primary_header: PrimaryHeader,
+    data_field_header: TransferFrameDataFieldHeader,
+    data: &'buf [u8],
+    operational_control_field: Option<u32>,
+}
+
+impl<'buf> TransferFrameReader<'buf> {
+    /// This function assumes an insert zone length of 0.
+    pub fn from_bytes(
+        buf: &'buf [u8],
+        has_fecf: bool,
+    ) -> Result<TransferFrameReader<'buf>, UslpError> {
+        let primary_header = PrimaryHeader::from_bytes(buf)?;
+        if primary_header.len_frame() > buf.len() {
+            return Err(ByteConversionError::FromSliceTooSmall {
+                expected: primary_header.len_frame(),
+                found: buf.len(),
+            }
+            .into());
+        }
+        let data_field_header =
+            TransferFrameDataFieldHeader::from_bytes(&buf[primary_header.len_header()..])?;
+        let data_idx = primary_header.len_header() + data_field_header.len_header();
+        let frame_len = primary_header.len_frame();
+        let mut operational_control_field = None;
+        let mut data_len = frame_len - data_idx;
+        if has_fecf {
+            data_len -= 2;
+        }
+        if primary_header.ocf_flag {
+            data_len -= 4;
+            operational_control_field = Some(u32::from_be_bytes(
+                buf[data_idx + data_len..data_idx + data_len + 4]
+                    .try_into()
+                    .unwrap(),
+            ));
+        }
+        let data_end = data_idx + data_len;
+        if has_fecf {
+            let mut digest = CRC_CCITT_FALSE.digest();
+            digest.update(&buf[0..frame_len]);
+            if digest.finalize() != 0 {
+                return Err(UslpError::ChecksumFailure(u16::from_be_bytes(
+                    buf[frame_len - 2..frame_len].try_into().unwrap(),
+                )));
+            }
+        }
+        Ok(Self {
+            primary_header,
+            data_field_header,
+            data: buf[data_idx..data_end].try_into().unwrap(),
+            operational_control_field,
+        })
+    }
+
+    #[inline]
+    pub fn len_frame(&self) -> usize {
+        self.primary_header.len_frame()
+    }
+
+    #[inline]
+    pub fn primary_header(&self) -> &PrimaryHeader {
+        &self.primary_header
+    }
+
+    #[inline]
+    pub fn data_field_header(&self) -> &TransferFrameDataFieldHeader {
+        &self.data_field_header
+    }
+
+    #[inline]
+    pub fn data(&self) -> &'buf [u8] {
+        self.data
+    }
+
+    #[inline]
+    pub fn operational_control_field(&self) -> &Option<u32> {
+        &self.operational_control_field
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn common_basic_check(buf: &[u8]) {
+        assert_eq!(buf[0] >> 4, USLP_VERSION_NUMBER);
+        // First four bits SCID.
+        assert_eq!(buf[0] & 0b1111, 0b1010);
+        // Next eight bits SCID.
+        assert_eq!(buf[1], 0b01011100);
+        // Last four bits SCID.
+        assert_eq!(buf[2] >> 4, 0b0011);
+        assert_eq!((buf[2] >> 3) & 0b1, SourceOrDestField::Dest as u8);
+        // First three bits VCID.
+        assert_eq!(buf[2] & 0b111, 0b110);
+        // Last three bits VCID.
+        assert_eq!(buf[3] >> 5, 0b101);
+        // MAP ID
+        assert_eq!((buf[3] >> 1) & 0b1111, 0b1010);
+        // End of primary header flag
+        assert_eq!(buf[3] & 0b1, 0);
+        assert_eq!(u16::from_be_bytes(buf[4..6].try_into().unwrap()), 0x2344);
+    }
+
+    #[test]
+    fn test_basic_0() {
+        let mut buf: [u8; 8] = [0; 8];
+        // Should be all zeros after writing.
+        buf[6] = 0xff;
+        let primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        // Virtual channel count 0.
+        assert_eq!(primary_header.write_to_be_bytes(&mut buf).unwrap(), 7);
+        common_basic_check(&buf);
+        assert_eq!(primary_header.vc_frame_count_len(), 0);
+        assert_eq!(primary_header.vc_frame_count(), 0);
+        // Bypass / Sequence Control Flag.
+        assert_eq!(
+            (buf[6] >> 7) & 0b1,
+            BypassSequenceControlFlag::SequenceControlledQoS as u8
+        );
+        // Protocol Control Command Flag.
+        assert_eq!(
+            (buf[6] >> 6) & 0b1,
+            ProtocolControlCommandFlag::TfdfContainsUserData as u8
+        );
+        // OCF flag.
+        assert_eq!((buf[6] >> 3) & 0b1, false as u8);
+        // VCF count length.
+        assert_eq!(buf[6] & 0b111, 0);
+    }
+
+    #[test]
+    fn test_basic_1() {
+        let mut buf: [u8; 16] = [0; 16];
+        // Should be all zeros after writing.
+        buf[6] = 0xff;
+        let mut primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        primary_header.sequence_control_flag = BypassSequenceControlFlag::ExpeditedQoS;
+        primary_header.protocol_control_command_flag =
+            ProtocolControlCommandFlag::TfdfContainsProtocolInfo;
+        primary_header.ocf_flag = true;
+        primary_header.set_vc_frame_count(4, 0x12345678).unwrap();
+        // Virtual channel count 4.
+        assert_eq!(primary_header.write_to_be_bytes(&mut buf).unwrap(), 11);
+        assert_eq!(primary_header.vc_frame_count_len(), 4);
+        assert_eq!(primary_header.vc_frame_count(), 0x12345678);
+        common_basic_check(&buf);
+        // Bypass / Sequence Control Flag.
+        assert_eq!(
+            (buf[6] >> 7) & 0b1,
+            BypassSequenceControlFlag::ExpeditedQoS as u8
+        );
+        // Protocol Control Command Flag.
+        assert_eq!(
+            (buf[6] >> 6) & 0b1,
+            ProtocolControlCommandFlag::TfdfContainsProtocolInfo as u8
+        );
+        // OCF flag.
+        assert_eq!((buf[6] >> 3) & 0b1, true as u8);
+        // VCF count length.
+        assert_eq!(buf[6] & 0b111, 4);
+        assert_eq!(
+            u32::from_be_bytes(buf[7..11].try_into().unwrap()),
+            0x12345678
+        );
+    }
+
+    #[test]
+    fn test_vcf_count_len_two() {
+        let mut buf: [u8; 16] = [0; 16];
+        // Should be all zeros after writing.
+        buf[6] = 0xff;
+        let mut primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        primary_header.set_vc_frame_count(2, 5).unwrap();
+        assert_eq!(primary_header.vc_frame_count_len(), 2);
+        assert_eq!(primary_header.vc_frame_count(), 5);
+        assert_eq!(primary_header.write_to_be_bytes(&mut buf).unwrap(), 9);
+        assert_eq!(buf[6] & 0b111, 2);
+        assert_eq!(u16::from_be_bytes(buf[7..9].try_into().unwrap()), 5);
+
+        let primary_header = PrimaryHeader::from_bytes(&buf).unwrap();
+        assert_eq!(primary_header.vc_frame_count_len(), 2);
+        assert_eq!(primary_header.vc_frame_count(), 5);
+    }
+
+    #[test]
+    fn test_vcf_count_len_one() {
+        let mut buf: [u8; 16] = [0; 16];
+        // Should be all zeros after writing.
+        buf[6] = 0xff;
+        let mut primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        primary_header.set_vc_frame_count(1, 255).unwrap();
+        assert_eq!(primary_header.vc_frame_count_len(), 1);
+        assert_eq!(primary_header.vc_frame_count(), 255);
+        assert_eq!(primary_header.write_to_be_bytes(&mut buf).unwrap(), 8);
+        assert_eq!(buf[6] & 0b111, 1);
+        assert_eq!(buf[7], 255);
+
+        let primary_header = PrimaryHeader::from_bytes(&buf).unwrap();
+        assert_eq!(primary_header.vc_frame_count_len(), 1);
+        assert_eq!(primary_header.vc_frame_count(), 255);
+    }
+
+    #[test]
+    fn test_reading_0() {
+        let mut buf: [u8; 8] = [0; 8];
+        let primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        assert_eq!(primary_header.write_to_be_bytes(&mut buf).unwrap(), 7);
+        let parsed_header = PrimaryHeader::from_bytes(&buf).unwrap();
+        assert_eq!(parsed_header, primary_header);
+    }
+
+    #[test]
+    fn test_reading_1() {
+        let mut buf: [u8; 16] = [0; 16];
+        let mut primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        primary_header.sequence_control_flag = BypassSequenceControlFlag::ExpeditedQoS;
+        primary_header.protocol_control_command_flag =
+            ProtocolControlCommandFlag::TfdfContainsProtocolInfo;
+        primary_header.ocf_flag = true;
+        primary_header.set_vc_frame_count(4, 0x12345678).unwrap();
+        assert_eq!(primary_header.write_to_be_bytes(&mut buf).unwrap(), 11);
+        let parsed_header = PrimaryHeader::from_bytes(&buf).unwrap();
+        assert_eq!(parsed_header, primary_header);
+    }
+
+    #[test]
+    fn test_invalid_vcid() {
+        let error = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b1101011,
+            0b1010,
+            0x2345,
+        );
+        assert!(error.is_err());
+        let error = error.unwrap_err();
+        matches!(error, UslpError::InvalidVcId(0b1101011));
+    }
+
+    #[test]
+    fn test_invalid_mapid() {
+        let error = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b10101,
+            0x2345,
+        );
+        assert!(error.is_err());
+        let error = error.unwrap_err();
+        matches!(error, UslpError::InvalidMapId(0b10101));
+    }
+
+    #[test]
+    fn test_invalid_vc_count() {
+        let mut primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        matches!(
+            primary_header.set_vc_frame_count(0, 1).unwrap_err(),
+            InvalidValueForLen { value: 1, len: 0 }
+        );
+        matches!(
+            primary_header.set_vc_frame_count(1, 256).unwrap_err(),
+            InvalidValueForLen { value: 256, len: 1 }
+        );
+    }
+
+    #[test]
+    fn test_frame_parser() {
+        let mut buf: [u8; 32] = [0; 32];
+        // Build a variable frame manually.
+        let mut primary_header =
+            PrimaryHeader::new(0x01, SourceOrDestField::Dest, 0b110101, 0b1010, 0).unwrap();
+        let header_len = primary_header.len_header();
+        buf[header_len] = ((ConstructionRule::NoSegmentation as u8) << 5)
+            | (UslpProtocolId::UserDefinedOctetStream as u8) & 0b11111;
+        buf[header_len + 1] = 0x42;
+        // 1 byte TFDH, 1 byte data, 2 bytes CRC.
+        primary_header.set_frame_len(header_len + 4);
+        primary_header.write_to_be_bytes(&mut buf).unwrap();
+        // Calculate and write CRC16.
+        let mut digest = CRC_CCITT_FALSE.digest();
+        digest.update(&buf[0..header_len + 2]);
+        buf[header_len + 2..header_len + 4].copy_from_slice(&digest.finalize().to_be_bytes());
+        // Now parse the frame.
+        let frame = TransferFrameReader::from_bytes(&buf, true).unwrap();
+        assert_eq!(*frame.primary_header(), primary_header);
+        assert_eq!(frame.data().len(), 1);
+        assert_eq!(frame.data()[0], 0x42);
+        assert_eq!(
+            frame.data_field_header().uslp_protocol_id(),
+            UslpProtocolId::UserDefinedOctetStream
+        );
+        assert_eq!(
+            frame.data_field_header().construction_rule(),
+            ConstructionRule::NoSegmentation
+        );
+        assert!(frame.data_field_header().fhp_or_lvo().is_none());
+        assert_eq!(frame.len_frame(), 11);
+        assert!(frame.operational_control_field().is_none());
+    }
+
+    #[test]
+    fn test_frame_parser_invalid_checksum() {
+        let mut buf: [u8; 32] = [0; 32];
+        // Build a variable frame manually.
+        let mut primary_header =
+            PrimaryHeader::new(0x01, SourceOrDestField::Dest, 0b110101, 0b1010, 0).unwrap();
+        let header_len = primary_header.len_header();
+        buf[header_len] = ((ConstructionRule::NoSegmentation as u8) << 5)
+            | (UslpProtocolId::UserDefinedOctetStream as u8) & 0b11111;
+        buf[header_len + 1] = 0x42;
+        // 1 byte TFDH, 1 byte data, 2 bytes CRC.
+        primary_header.set_frame_len(header_len + 4);
+        primary_header.write_to_be_bytes(&mut buf).unwrap();
+        // Now parse the frame without having calculated the checksum.
+        match TransferFrameReader::from_bytes(&buf, true) {
+            Ok(_) => panic!("transfer frame read call did not fail"),
+            Err(e) => {
+                assert_eq!(e, UslpError::ChecksumFailure(0));
+            }
+        }
+    }
+
+    #[test]
+    fn test_frame_parser_buf_too_small() {
+        let mut buf: [u8; 32] = [0; 32];
+        // Build a variable frame manually.
+        let mut primary_header =
+            PrimaryHeader::new(0x01, SourceOrDestField::Dest, 0b110101, 0b1010, 0).unwrap();
+        let header_len = primary_header.len_header();
+        buf[header_len] = ((ConstructionRule::NoSegmentation as u8) << 5)
+            | (UslpProtocolId::UserDefinedOctetStream as u8) & 0b11111;
+        buf[header_len + 1] = 0x42;
+        // 1 byte TFDH, 1 byte data, 2 bytes CRC.
+        primary_header.set_frame_len(header_len + 4);
+        primary_header.write_to_be_bytes(&mut buf).unwrap();
+        // Now parse the frame.
+        let error = TransferFrameReader::from_bytes(&buf[0..7], true).unwrap_err();
+        assert_eq!(
+            error,
+            ByteConversionError::FromSliceTooSmall {
+                expected: primary_header.len_frame(),
+                found: 7
+            }
+            .into()
+        );
+    }
+
+    #[test]
+    fn test_from_bytes_too_small_0() {
+        let buf: [u8; 3] = [0; 3];
+        assert_eq!(
+            PrimaryHeader::from_bytes(&buf).unwrap_err(),
+            ByteConversionError::FromSliceTooSmall {
+                found: 3,
+                expected: 4
+            }
+            .into()
+        );
+    }
+
+    #[test]
+    fn test_from_bytes_too_small_1() {
+        let buf: [u8; 6] = [0; 6];
+        assert_eq!(
+            PrimaryHeader::from_bytes(&buf).unwrap_err(),
+            ByteConversionError::FromSliceTooSmall {
+                found: 6,
+                expected: 7
+            }
+            .into()
+        );
+    }
+
+    #[test]
+    fn test_from_bytes_truncated_not_supported() {
+        let mut buf: [u8; 7] = [0; 7];
+        let primary_header =
+            PrimaryHeader::new(0x01, SourceOrDestField::Dest, 0b110101, 0b1010, 0).unwrap();
+        primary_header.write_to_be_bytes(&mut buf).unwrap();
+        // Set truncated header flag manually.
+        buf[3] |= 0b1;
+        assert_eq!(
+            PrimaryHeader::from_bytes(&buf).unwrap_err(),
+            UslpError::HeaderIsTruncated
+        );
+    }
+
+    #[test]
+    fn test_from_bytes_too_small_2() {
+        let mut buf: [u8; 16] = [0; 16];
+        // Should be all zeros after writing.
+        buf[6] = 0xff;
+        let mut primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        primary_header.set_vc_frame_count(4, 0x12345678).unwrap();
+        primary_header.write_to_be_bytes(&mut buf).unwrap();
+
+        assert_eq!(
+            PrimaryHeader::from_bytes(&buf[0..8]).unwrap_err(),
+            UslpError::ByteConversion(ByteConversionError::FromSliceTooSmall {
+                found: 8,
+                expected: 11
+            })
+        );
+    }
+
+    #[test]
+    fn test_invalid_version_number() {
+        let mut buf: [u8; 7] = [0; 7];
+        let primary_header =
+            PrimaryHeader::new(0x01, SourceOrDestField::Dest, 0b110101, 0b1010, 0).unwrap();
+        primary_header.write_to_be_bytes(&mut buf).unwrap();
+        buf[0] &= 0b00001111;
+        assert_eq!(
+            PrimaryHeader::from_bytes(&buf).unwrap_err(),
+            UslpError::InvalidVersionNumber(0)
+        );
+    }
+
+    #[test]
+    fn test_primary_header_buf_too_small() {
+        let primary_header = PrimaryHeader::new(
+            0b10100101_11000011,
+            SourceOrDestField::Dest,
+            0b110101,
+            0b1010,
+            0x2345,
+        )
+        .unwrap();
+        if let Err(ByteConversionError::ToSliceTooSmall { found, expected }) =
+            primary_header.write_to_be_bytes(&mut [0; 4])
+        {
+            assert_eq!(found, 4);
+            assert_eq!(expected, 7);
+        } else {
+            panic!("writing primary header did not fail or failed with wrong error");
+        }
+    }
+
+    #[test]
+    fn test_applicability_contr_rules() {
+        assert!(ConstructionRule::PacketSpanningMultipleFrames.applicable_to_fixed_len_tfdz());
+        assert!(ConstructionRule::StartOfMapaSduOrVcaSdu.applicable_to_fixed_len_tfdz());
+        assert!(ConstructionRule::ContinuingPortionOfMapaSdu.applicable_to_fixed_len_tfdz());
+        assert!(!ConstructionRule::OctetStream.applicable_to_fixed_len_tfdz());
+        assert!(!ConstructionRule::StartingSegment.applicable_to_fixed_len_tfdz());
+        assert!(!ConstructionRule::ContinuingSegment.applicable_to_fixed_len_tfdz());
+        assert!(!ConstructionRule::LastSegment.applicable_to_fixed_len_tfdz());
+        assert!(!ConstructionRule::NoSegmentation.applicable_to_fixed_len_tfdz());
+    }
+
+    #[test]
+    fn test_header_len_correctness() {
+        let mut tfdh = TransferFrameDataFieldHeader {
+            construction_rule: ConstructionRule::PacketSpanningMultipleFrames,
+            uslp_protocol_id: UslpProtocolId::UserDefinedOctetStream,
+            fhp_or_lvo: Some(0),
+        };
+        assert_eq!(tfdh.len_header(), 3);
+        tfdh = TransferFrameDataFieldHeader {
+            construction_rule: ConstructionRule::StartOfMapaSduOrVcaSdu,
+            uslp_protocol_id: UslpProtocolId::UserDefinedOctetStream,
+            fhp_or_lvo: Some(0),
+        };
+        assert_eq!(tfdh.len_header(), 3);
+        tfdh = TransferFrameDataFieldHeader {
+            construction_rule: ConstructionRule::ContinuingPortionOfMapaSdu,
+            uslp_protocol_id: UslpProtocolId::UserDefinedOctetStream,
+            fhp_or_lvo: Some(0),
+        };
+        assert_eq!(tfdh.len_header(), 3);
+        tfdh = TransferFrameDataFieldHeader {
+            construction_rule: ConstructionRule::OctetStream,
+            uslp_protocol_id: UslpProtocolId::UserDefinedOctetStream,
+            fhp_or_lvo: None,
+        };
+        assert_eq!(tfdh.len_header(), 1);
+    }
+
+    #[test]
+    fn test_frame_data_field_header_from_bytes_too_small() {
+        let buf: [u8; 0] = [];
+        assert_eq!(
+            TransferFrameDataFieldHeader::from_bytes(&buf).unwrap_err(),
+            ByteConversionError::FromSliceTooSmall {
+                found: 0,
+                expected: 1
+            }
+            .into()
+        );
+    }
+}

src/util.rs

@@ -1,9 +1,7 @@
 use crate::ByteConversionError;
-use core::fmt::{Debug, Display, Formatter};
+use core::fmt::Debug;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-#[cfg(feature = "std")]
-use std::error::Error;
 
 pub trait ToBeBytes {
     type ByteArray: AsRef<[u8]>;
@@ -100,49 +98,24 @@ pub trait UnsignedEnum {
 
 pub trait UnsignedEnumExt: UnsignedEnum + Debug + Copy + Clone + PartialEq + Eq {}
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum UnsignedByteFieldError {
     /// Value is too large for specified width of byte field.
-    ValueTooLargeForWidth {
-        width: usize,
-        value: u64,
-    },
+    #[error("value {value} too large for width {width}")]
+    ValueTooLargeForWidth { width: usize, value: u64 },
     /// Only 1, 2, 4 and 8 are allow width values. Optionally contains the expected width if
     /// applicable, for example for conversions.
+    #[error("invalid width {found}, expected {expected:?}")]
     InvalidWidth {
         found: usize,
         expected: Option<usize>,
     },
-    ByteConversionError(ByteConversionError),
+    #[error("byte conversion error: {0}")]
+    ByteConversionError(#[from] ByteConversionError),
 }
 
-impl From<ByteConversionError> for UnsignedByteFieldError {
-    #[inline]
-    fn from(value: ByteConversionError) -> Self {
-        Self::ByteConversionError(value)
-    }
-}
-
-impl Display for UnsignedByteFieldError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Self::ByteConversionError(e) => {
-                write!(f, "low level byte conversion error: {e}")
-            }
-            Self::InvalidWidth { found, .. } => {
-                write!(f, "invalid width {found}, only 1, 2, 4 and 8 are allowed.")
-            }
-            Self::ValueTooLargeForWidth { width, value } => {
-                write!(f, "value {value} too large for width {width}")
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for UnsignedByteFieldError {}
-
 /// Type erased variant.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]