Compare commits
1 Commits
add-basic-
...
3c2d6703e2
| Author | SHA1 | Date | |
|---|---|---|---|
| 3c2d6703e2 |
4
.github/workflows/ci.yml
vendored
4
.github/workflows/ci.yml
vendored
@ -29,7 +29,7 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: dtolnay/rust-toolchain@1.70.0
|
||||
- uses: dtolnay/rust-toolchain@1.68.2
|
||||
- run: cargo check --release
|
||||
|
||||
cross-check:
|
||||
@ -61,7 +61,7 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: dtolnay/rust-toolchain@nightly
|
||||
- run: RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options" cargo +nightly doc --all-features
|
||||
- run: cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]'
|
||||
|
||||
clippy:
|
||||
name: Clippy
|
||||
|
||||
73
CHANGELOG.md
73
CHANGELOG.md
@ -8,81 +8,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
|
||||
|
||||
# [unreleased]
|
||||
|
||||
## 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
|
||||
# [v0.12.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
|
||||
|
||||
@ -590,9 +525,3 @@ 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.14.0...HEAD
|
||||
[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
|
||||
|
||||
70
Cargo.toml
70
Cargo.toml
@ -1,8 +1,8 @@
|
||||
[package]
|
||||
name = "spacepackets"
|
||||
version = "0.14.0"
|
||||
version = "0.11.2"
|
||||
edition = "2021"
|
||||
rust-version = "1.70.0"
|
||||
rust-version = "1.68.2"
|
||||
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"
|
||||
@ -13,30 +13,58 @@ categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-sup
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
crc = "3.3"
|
||||
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"] }
|
||||
crc = "3"
|
||||
delegate = ">=0.8, <0.11"
|
||||
|
||||
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 }
|
||||
[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"
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
std = ["alloc", "chrono/std", "chrono/clock", "thiserror/std"]
|
||||
serde = ["dep:serde", "chrono?/serde"]
|
||||
alloc = ["chrono?/alloc", "defmt?/alloc", "serde?/alloc"]
|
||||
std = ["chrono/std", "chrono/clock", "alloc", "thiserror"]
|
||||
serde = ["dep:serde", "chrono/serde"]
|
||||
alloc = ["postcard/alloc", "chrono/alloc", "defmt/alloc", "serde/alloc"]
|
||||
chrono = ["dep:chrono"]
|
||||
timelib = ["dep:time"]
|
||||
|
||||
[dev-dependencies]
|
||||
postcard = { version = "1", features = ["alloc"] }
|
||||
chrono = "0.4"
|
||||
defmt = ["dep:defmt"]
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
all-features = true
|
||||
rustdoc-args = ["--generate-link-to-definition"]
|
||||
rustdoc-args = ["--cfg", "docs_rs", "--generate-link-to-definition"]
|
||||
|
||||
@ -1 +0,0 @@
|
||||
github: robamu
|
||||
@ -1,6 +1,7 @@
|
||||
[](https://crates.io/crates/spacepackets)
|
||||
[](https://docs.rs/spacepackets)
|
||||
[](https://github.com/us-irs/spacepackets-rs/actions/workflows/ci.yml)
|
||||
[](https://absatsw.irs.uni-stuttgart.de/projects/spacepackets/coverage-rs/latest/index.html)
|
||||
|
||||
ECSS and CCSDS Spacepackets
|
||||
======
|
||||
|
||||
4
automation/Jenkinsfile
vendored
4
automation/Jenkinsfile
vendored
@ -21,9 +21,7 @@ pipeline {
|
||||
}
|
||||
stage('Docs') {
|
||||
steps {
|
||||
sh """
|
||||
RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options" cargo +nightly doc --all-features
|
||||
"""
|
||||
sh 'cargo +nightly doc --all-features'
|
||||
}
|
||||
}
|
||||
stage('Rustfmt') {
|
||||
|
||||
3
docs.sh
3
docs.sh
@ -1,3 +0,0 @@
|
||||
#!/bin/sh
|
||||
export RUSTDOCFLAGS="--cfg docsrs --generate-link-to-definition -Z unstable-options"
|
||||
cargo +nightly doc --all-features --open
|
||||
@ -4,9 +4,7 @@ Checklist for new releases
|
||||
# Pre-Release
|
||||
|
||||
1. Make sure any new modules are documented sufficiently enough and check docs with
|
||||
`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).
|
||||
`cargo +nightly doc --all-features --config 'build.rustdocflags=["--cfg", "docs_rs"]' --open`.
|
||||
2. Bump version specifier in `Cargo.toml`.
|
||||
3. Update `CHANGELOG.md`: Convert `unreleased` section into version section with date and add new
|
||||
`unreleased` section.
|
||||
|
||||
@ -1,4 +1,5 @@
|
||||
//! 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")]
|
||||
@ -6,8 +7,6 @@ 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.
|
||||
@ -64,9 +63,9 @@ pub(crate) fn generic_len_check_deserialization(
|
||||
|
||||
impl<'data> Lv<'data> {
|
||||
#[inline]
|
||||
pub fn new(data: &[u8]) -> Result<Lv, TlvLvDataTooLargeError> {
|
||||
pub fn new(data: &[u8]) -> Result<Lv, TlvLvError> {
|
||||
if data.len() > u8::MAX as usize {
|
||||
return Err(TlvLvDataTooLargeError(data.len()));
|
||||
return Err(TlvLvError::DataTooLarge(data.len()));
|
||||
}
|
||||
Ok(Lv {
|
||||
data,
|
||||
@ -86,7 +85,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, TlvLvDataTooLargeError> {
|
||||
pub fn new_from_str(str_slice: &str) -> Result<Lv, TlvLvError> {
|
||||
Self::new(str_slice.as_bytes())
|
||||
}
|
||||
|
||||
@ -94,7 +93,7 @@ impl<'data> Lv<'data> {
|
||||
/// path LVs
|
||||
#[cfg(feature = "std")]
|
||||
#[inline]
|
||||
pub fn new_from_string(string: &'data String) -> Result<Lv<'data>, TlvLvDataTooLargeError> {
|
||||
pub fn new_from_string(string: &'data String) -> Result<Lv<'data>, TlvLvError> {
|
||||
Self::new(string.as_bytes())
|
||||
}
|
||||
|
||||
@ -178,10 +177,10 @@ impl<'data> Lv<'data> {
|
||||
|
||||
#[cfg(test)]
|
||||
pub mod tests {
|
||||
use super::*;
|
||||
use alloc::string::ToString;
|
||||
|
||||
use super::*;
|
||||
|
||||
use crate::cfdp::TlvLvError;
|
||||
use crate::ByteConversionError;
|
||||
use std::string::String;
|
||||
|
||||
@ -272,11 +271,15 @@ pub mod tests {
|
||||
let lv = Lv::new(&data_big);
|
||||
assert!(lv.is_err());
|
||||
let error = lv.unwrap_err();
|
||||
assert_eq!(error.0, u8::MAX as usize + 1);
|
||||
assert_eq!(
|
||||
error.to_string(),
|
||||
"data with size 256 larger than allowed 255 bytes"
|
||||
);
|
||||
if let TlvLvError::DataTooLarge(size) = error {
|
||||
assert_eq!(size, 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]
|
||||
|
||||
@ -1,8 +1,11 @@
|
||||
//! 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;
|
||||
@ -113,7 +116,7 @@ pub enum ConditionCode {
|
||||
FileSizeError = 0b0110,
|
||||
NakLimitReached = 0b0111,
|
||||
InactivityDetected = 0b1000,
|
||||
CheckLimitReached = 0b1010,
|
||||
CheckLimitReached = 0b1001,
|
||||
UnsupportedChecksumType = 0b1011,
|
||||
/// Not an actual fault condition for which fault handler overrides can be specified
|
||||
SuspendRequestReceived = 0b1110,
|
||||
@ -173,43 +176,76 @@ impl Default for ChecksumType {
|
||||
|
||||
pub const NULL_CHECKSUM_U32: [u8; 4] = [0; 4];
|
||||
|
||||
#[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)]
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
||||
pub enum TlvLvError {
|
||||
#[error("{0}")]
|
||||
DataTooLarge(#[from] TlvLvDataTooLargeError),
|
||||
#[error("byte conversion error: {0}")]
|
||||
ByteConversion(#[from] ByteConversionError),
|
||||
#[error("{0}")]
|
||||
InvalidTlvTypeField(#[from] InvalidTlvTypeFieldError),
|
||||
#[error("invalid value length {0}")]
|
||||
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.
|
||||
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::*;
|
||||
|
||||
@ -25,36 +25,20 @@ pub struct EofPdu {
|
||||
}
|
||||
|
||||
impl EofPdu {
|
||||
pub fn new(
|
||||
mut pdu_header: PduHeader,
|
||||
condition_code: ConditionCode,
|
||||
file_checksum: u32,
|
||||
file_size: u64,
|
||||
fault_location: Option<EntityIdTlv>,
|
||||
) -> Self {
|
||||
pub fn new_no_error(mut pdu_header: PduHeader, file_checksum: u32, file_size: u64) -> Self {
|
||||
// Force correct direction flag.
|
||||
pdu_header.pdu_conf.direction = Direction::TowardsReceiver;
|
||||
let mut eof_pdu = Self {
|
||||
pdu_header,
|
||||
condition_code,
|
||||
condition_code: ConditionCode::NoError,
|
||||
file_checksum,
|
||||
file_size,
|
||||
fault_location,
|
||||
fault_location: None,
|
||||
};
|
||||
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,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn pdu_header(&self) -> &PduHeader {
|
||||
&self.pdu_header
|
||||
}
|
||||
@ -164,7 +148,7 @@ impl WritablePduPacket for EofPdu {
|
||||
&mut buf[current_idx..],
|
||||
)?;
|
||||
if let Some(fault_location) = self.fault_location {
|
||||
current_idx += fault_location.write_to_bytes(&mut buf[current_idx..])?;
|
||||
current_idx += fault_location.write_to_bytes(buf)?;
|
||||
}
|
||||
if self.crc_flag() == CrcFlag::WithCrc {
|
||||
current_idx = add_pdu_crc(buf, current_idx);
|
||||
@ -187,23 +171,13 @@ 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_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,
|
||||
) {
|
||||
fn verify_state(&eof_pdu: &EofPdu, file_flag: LargeFileFlag) {
|
||||
assert_eq!(eof_pdu.file_checksum(), 0x01020304);
|
||||
assert_eq!(eof_pdu.file_size(), 12);
|
||||
assert_eq!(eof_pdu.condition_code(), cond_code);
|
||||
assert_eq!(eof_pdu.condition_code(), ConditionCode::NoError);
|
||||
|
||||
assert_eq!(eof_pdu.crc_flag(), crc_flag);
|
||||
assert_eq!(eof_pdu.crc_flag(), CrcFlag::NoCrc);
|
||||
assert_eq!(eof_pdu.file_flag(), file_flag);
|
||||
assert_eq!(eof_pdu.pdu_type(), PduType::FileDirective);
|
||||
assert_eq!(
|
||||
@ -223,7 +197,7 @@ mod tests {
|
||||
let pdu_header = PduHeader::new_no_file_data(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_no_error_no_crc(&eof_pdu, LargeFileFlag::Normal);
|
||||
verify_state(&eof_pdu, LargeFileFlag::Normal);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -297,7 +271,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::Checksum(e) = error {
|
||||
if let PduError::ChecksumError(e) = error {
|
||||
assert_eq!(e, crc);
|
||||
} else {
|
||||
panic!("expected crc error");
|
||||
@ -309,7 +283,7 @@ mod tests {
|
||||
let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Large);
|
||||
let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0);
|
||||
let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12);
|
||||
verify_state_no_error_no_crc(&eof_pdu, LargeFileFlag::Large);
|
||||
verify_state(&eof_pdu, LargeFileFlag::Large);
|
||||
assert_eq!(eof_pdu.len_written(), pdu_header.header_len() + 2 + 8 + 4);
|
||||
}
|
||||
|
||||
@ -321,48 +295,4 @@ mod tests {
|
||||
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_no_file_data(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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -92,67 +92,16 @@ 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<'_> {
|
||||
fn pdu_header(&self) -> &PduHeader {
|
||||
&self.pdu_header
|
||||
}
|
||||
|
||||
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().written_len()
|
||||
}
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// 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))]
|
||||
common: FdPduBase<'seg_meta>,
|
||||
segment_metadata: Option<SegmentMetadata<'seg_meta>>,
|
||||
offset: u64,
|
||||
file_data: &'file_data [u8],
|
||||
}
|
||||
|
||||
@ -185,34 +134,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,
|
||||
},
|
||||
pdu_header,
|
||||
segment_metadata,
|
||||
offset,
|
||||
file_data,
|
||||
};
|
||||
pdu.common.pdu_header.pdu_datafield_len = pdu.calc_pdu_datafield_len() as u16;
|
||||
pdu.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() as u64)
|
||||
}
|
||||
|
||||
pub fn segment_metadata(&self) -> Option<&SegmentMetadata> {
|
||||
self.common.segment_metadata.as_ref()
|
||||
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
|
||||
}
|
||||
|
||||
pub fn offset(&self) -> u64 {
|
||||
self.common.offset
|
||||
self.offset
|
||||
}
|
||||
|
||||
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)?;
|
||||
@ -233,18 +190,16 @@ impl<'seg_meta, 'file_data> FileDataPdu<'seg_meta, 'file_data> {
|
||||
.into());
|
||||
}
|
||||
Ok(Self {
|
||||
common: FdPduBase {
|
||||
pdu_header,
|
||||
segment_metadata,
|
||||
offset,
|
||||
},
|
||||
pdu_header,
|
||||
segment_metadata,
|
||||
offset,
|
||||
file_data: &buf[current_idx..full_len_without_crc],
|
||||
})
|
||||
}
|
||||
}
|
||||
impl CfdpPdu for FileDataPdu<'_, '_> {
|
||||
fn pdu_header(&self) -> &PduHeader {
|
||||
&self.common.pdu_header
|
||||
&self.pdu_header
|
||||
}
|
||||
|
||||
fn file_directive_type(&self) -> Option<FileDirectiveType> {
|
||||
@ -261,8 +216,19 @@ impl WritablePduPacket for FileDataPdu<'_, '_> {
|
||||
}
|
||||
.into());
|
||||
}
|
||||
|
||||
let mut current_idx = self.common.write_common_fields_to_bytes(buf)?;
|
||||
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..],
|
||||
)?;
|
||||
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 {
|
||||
@ -272,167 +238,10 @@ impl WritablePduPacket for FileDataPdu<'_, '_> {
|
||||
}
|
||||
|
||||
fn len_written(&self) -> usize {
|
||||
self.common.pdu_header.header_len() + self.calc_pdu_datafield_len()
|
||||
self.pdu_header.header_len() + self.calc_pdu_datafield_len()
|
||||
}
|
||||
}
|
||||
|
||||
/// 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 segment_metadata.is_some() {
|
||||
subtract += 1 + segment_metadata.as_ref().unwrap().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 {
|
||||
use super::*;
|
||||
@ -454,7 +263,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);
|
||||
@ -481,11 +290,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(),
|
||||
);
|
||||
@ -544,7 +353,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::Checksum(e) = error {
|
||||
if let PduError::ChecksumError(e) = error {
|
||||
assert_eq!(e, crc);
|
||||
} else {
|
||||
panic!("expected crc error");
|
||||
@ -571,7 +380,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>()
|
||||
@ -581,7 +390,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
|
||||
@ -673,142 +482,4 @@ 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
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -4,14 +4,14 @@ use crate::cfdp::pdu::{
|
||||
use crate::cfdp::tlv::{
|
||||
EntityIdTlv, FilestoreResponseTlv, GenericTlv, Tlv, TlvType, TlvTypeField, WritableTlv,
|
||||
};
|
||||
use crate::cfdp::{ConditionCode, CrcFlag, Direction, PduType};
|
||||
use crate::cfdp::{ConditionCode, CrcFlag, Direction, PduType, TlvLvError};
|
||||
use crate::ByteConversionError;
|
||||
use num_enum::{IntoPrimitive, TryFromPrimitive};
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use super::tlv::ReadableTlv;
|
||||
use super::{CfdpPdu, InvalidTlvTypeFieldError, WritablePduPacket};
|
||||
use super::{CfdpPdu, WritablePduPacket};
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq, TryFromPrimitive, IntoPrimitive)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
@ -332,26 +332,22 @@ 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::Format);
|
||||
return Err(PduError::FormatError);
|
||||
}
|
||||
} else {
|
||||
return Err(PduError::TlvLv(
|
||||
InvalidTlvTypeFieldError {
|
||||
found: tlv_type.into(),
|
||||
expected: Some(TlvType::FilestoreResponse.into()),
|
||||
}
|
||||
.into(),
|
||||
));
|
||||
return Err(TlvLvError::InvalidTlvTypeField {
|
||||
found: tlv_type.into(),
|
||||
expected: Some(TlvType::FilestoreResponse.into()),
|
||||
}
|
||||
.into());
|
||||
}
|
||||
}
|
||||
TlvTypeField::Custom(raw) => {
|
||||
return Err(PduError::TlvLv(
|
||||
InvalidTlvTypeFieldError {
|
||||
found: raw,
|
||||
expected: None,
|
||||
}
|
||||
.into(),
|
||||
));
|
||||
return Err(TlvLvError::InvalidTlvTypeField {
|
||||
found: raw,
|
||||
expected: None,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -568,7 +564,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::Checksum(e) = error {
|
||||
if let PduError::ChecksumError(e) = error {
|
||||
assert_eq!(e, crc);
|
||||
} else {
|
||||
panic!("expected crc error");
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
#[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,
|
||||
@ -54,15 +52,6 @@ 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
|
||||
@ -73,7 +62,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 [u8],
|
||||
options: &'opts [Tlv<'opts>],
|
||||
}
|
||||
|
||||
impl<'src_name, 'dest_name, 'opts> MetadataPduCreator<'src_name, 'dest_name, 'opts> {
|
||||
@ -97,7 +86,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 [u8],
|
||||
options: &'opts [Tlv<'opts>],
|
||||
) -> Self {
|
||||
Self::new(
|
||||
pdu_header,
|
||||
@ -113,7 +102,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 [u8],
|
||||
options: &'opts [Tlv<'opts>],
|
||||
) -> Self {
|
||||
pdu_header.pdu_type = PduType::FileDirective;
|
||||
pdu_header.pdu_conf.direction = Direction::TowardsReceiver;
|
||||
@ -140,19 +129,10 @@ impl<'src_name, 'dest_name, 'opts> MetadataPduCreator<'src_name, 'dest_name, 'op
|
||||
self.dest_file_name
|
||||
}
|
||||
|
||||
pub fn options(&self) -> &'opts [u8] {
|
||||
pub fn options(&self) -> &'opts [Tlv<'opts>] {
|
||||
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;
|
||||
@ -163,7 +143,9 @@ 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();
|
||||
len += self.options().len();
|
||||
for tlv in self.options() {
|
||||
len += tlv.len_full()
|
||||
}
|
||||
if self.crc_flag() == CrcFlag::WithCrc {
|
||||
len += 2;
|
||||
}
|
||||
@ -209,8 +191,10 @@ impl WritablePduPacket for MetadataPduCreator<'_, '_, '_> {
|
||||
current_idx += self
|
||||
.dest_file_name
|
||||
.write_to_be_bytes(&mut buf[current_idx..])?;
|
||||
buf[current_idx..current_idx + self.options.len()].copy_from_slice(self.options);
|
||||
current_idx += self.options.len();
|
||||
for opt in self.options() {
|
||||
opt.write_to_bytes(&mut buf[current_idx..current_idx + opt.len_full()])?;
|
||||
current_idx += opt.len_full();
|
||||
}
|
||||
if self.crc_flag() == CrcFlag::WithCrc {
|
||||
current_idx = add_pdu_crc(buf, current_idx);
|
||||
}
|
||||
@ -371,7 +355,7 @@ pub mod tests {
|
||||
};
|
||||
use crate::cfdp::pdu::{CfdpPdu, PduError, WritablePduPacket};
|
||||
use crate::cfdp::pdu::{FileDirectiveType, PduHeader};
|
||||
use crate::cfdp::tlv::{ReadableTlv, Tlv, TlvOwned, TlvType, WritableTlv};
|
||||
use crate::cfdp::tlv::{ReadableTlv, Tlv, TlvType};
|
||||
use crate::cfdp::{
|
||||
ChecksumType, CrcFlag, Direction, LargeFileFlag, PduType, SegmentMetadataFlag,
|
||||
SegmentationControl, TransmissionMode,
|
||||
@ -381,16 +365,16 @@ pub mod tests {
|
||||
const SRC_FILENAME: &str = "hello-world.txt";
|
||||
const DEST_FILENAME: &str = "hello-world2.txt";
|
||||
|
||||
fn generic_metadata_pdu(
|
||||
fn generic_metadata_pdu<'opts>(
|
||||
crc_flag: CrcFlag,
|
||||
checksum_type: ChecksumType,
|
||||
closure_requested: bool,
|
||||
fss: LargeFileFlag,
|
||||
opts: &[u8],
|
||||
opts: &'opts [Tlv],
|
||||
) -> (
|
||||
Lv<'static>,
|
||||
Lv<'static>,
|
||||
MetadataPduCreator<'static, 'static, '_>,
|
||||
MetadataPduCreator<'static, 'static, 'opts>,
|
||||
) {
|
||||
let pdu_header = PduHeader::new_no_file_data(common_pdu_conf(crc_flag, fss), 0);
|
||||
let metadata_params = MetadataGenericParams::new(closure_requested, checksum_type, 0x1010);
|
||||
@ -560,9 +544,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_iter();
|
||||
for (tlv_written, tlv_read) in opts.zip(read.options_iter().unwrap()) {
|
||||
assert_eq!(&tlv_written, &tlv_read);
|
||||
let opts = written.options();
|
||||
for (tlv_written, tlv_read) in opts.iter().zip(read.options_iter().unwrap()) {
|
||||
assert_eq!(tlv_written, &tlv_read);
|
||||
}
|
||||
}
|
||||
|
||||
@ -677,14 +661,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 mut tlv_buf: [u8; 64] = [0; 64];
|
||||
let opts_len = build_metadata_opts_from_slice(&mut tlv_buf, &[tlv1, tlv2]).unwrap();
|
||||
let tlv_vec = vec![tlv1, tlv2];
|
||||
let opts_len = tlv1.len_full() + tlv2.len_full();
|
||||
let (src_filename, dest_filename, metadata_pdu) = generic_metadata_pdu(
|
||||
CrcFlag::NoCrc,
|
||||
ChecksumType::Crc32,
|
||||
false,
|
||||
LargeFileFlag::Normal,
|
||||
&tlv_buf[0..opts_len],
|
||||
&tlv_vec,
|
||||
);
|
||||
let mut buf: [u8; 128] = [0; 128];
|
||||
let write_res = metadata_pdu.write_to_bytes(&mut buf);
|
||||
@ -707,55 +691,7 @@ pub mod tests {
|
||||
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());
|
||||
}
|
||||
#[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);
|
||||
}
|
||||
assert_eq!(tlv_vec[idx], opt);
|
||||
accumulated_len += opt.len_full();
|
||||
}
|
||||
assert_eq!(accumulated_len, pdu_read_back.options().len());
|
||||
@ -780,7 +716,7 @@ pub mod tests {
|
||||
assert_eq!(expected, Some(FileDirectiveType::MetadataPdu));
|
||||
assert_eq!(
|
||||
error.to_string(),
|
||||
"invalid directive type, found 255, expected Some(MetadataPdu)"
|
||||
"invalid directive type value 255, expected Some(MetadataPdu)"
|
||||
);
|
||||
} else {
|
||||
panic!("Expected InvalidDirectiveType error, got {:?}", error);
|
||||
@ -806,7 +742,7 @@ pub mod tests {
|
||||
assert_eq!(expected, FileDirectiveType::MetadataPdu);
|
||||
assert_eq!(
|
||||
error.to_string(),
|
||||
"wrong directive type, found EofPdu, expected MetadataPdu"
|
||||
"found directive type EofPdu, expected MetadataPdu"
|
||||
);
|
||||
} else {
|
||||
panic!("Expected InvalidDirectiveType error, got {:?}", error);
|
||||
|
||||
@ -1,10 +1,13 @@
|
||||
//! CFDP Packet Data Unit (PDU) support.
|
||||
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;
|
||||
@ -27,62 +30,137 @@ pub enum FileDirectiveType {
|
||||
KeepAlivePdu = 0x0c,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
||||
pub enum PduError {
|
||||
#[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)]
|
||||
ByteConversion(ByteConversionError),
|
||||
/// Found version ID invalid, not equal to [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.
|
||||
#[error("invalid directive type, found {found:?}, expected {expected:?}")]
|
||||
InvalidDirectiveType {
|
||||
found: u8,
|
||||
expected: Option<FileDirectiveType>,
|
||||
},
|
||||
#[error("invalid start or end of scope value for NAK PDU")]
|
||||
InvalidStartOrEndOfScopeValue,
|
||||
/// 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.
|
||||
#[error("checksum error for checksum {0}")]
|
||||
Checksum(u16),
|
||||
ChecksumError(u16),
|
||||
/// Generic error for invalid PDU formats.
|
||||
#[error("generic PDU format error")]
|
||||
Format,
|
||||
FormatError,
|
||||
/// Error handling a TLV field.
|
||||
#[error("PDU error: {0}")]
|
||||
TlvLv(#[from] TlvLvError),
|
||||
TlvLvError(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"
|
||||
)
|
||||
}
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
pub trait WritablePduPacket {
|
||||
@ -454,7 +532,7 @@ impl PduHeader {
|
||||
let mut digest = CRC_CCITT_FALSE.digest();
|
||||
digest.update(&buf[..self.pdu_len()]);
|
||||
if digest.finalize() != 0 {
|
||||
return Err(PduError::Checksum(u16::from_be_bytes(
|
||||
return Err(PduError::ChecksumError(u16::from_be_bytes(
|
||||
buf[self.pdu_len() - 2..self.pdu_len()].try_into().unwrap(),
|
||||
)));
|
||||
}
|
||||
@ -903,7 +981,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);
|
||||
@ -951,7 +1029,7 @@ mod tests {
|
||||
assert_eq!(expected, 7);
|
||||
assert_eq!(
|
||||
error.to_string(),
|
||||
"byte conversion error: source slice with size 6 too small, expected at least 7 bytes"
|
||||
"source slice with size 6 too small, expected at least 7 bytes"
|
||||
);
|
||||
}
|
||||
}
|
||||
@ -1006,7 +1084,7 @@ mod tests {
|
||||
assert_eq!(dest_id_len, 2);
|
||||
assert_eq!(
|
||||
error.to_string(),
|
||||
"missmatch of PDU source ID length 1 and destination ID length 2"
|
||||
"missmatch of PDU source length 1 and destination length 2"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -61,7 +61,7 @@ impl<'seg_reqs> NakPduCreator<'seg_reqs> {
|
||||
start_of_scope: u32,
|
||||
end_of_scope: u32,
|
||||
segment_requests: &'seg_reqs [(u32, u32)],
|
||||
) -> Result<NakPduCreator<'seg_reqs>, PduError> {
|
||||
) -> Result<NakPduCreator, PduError> {
|
||||
let mut passed_segment_requests = None;
|
||||
if !segment_requests.is_empty() {
|
||||
passed_segment_requests = Some(SegmentRequests::U32Pairs(segment_requests));
|
||||
@ -79,7 +79,7 @@ impl<'seg_reqs> NakPduCreator<'seg_reqs> {
|
||||
start_of_scope: u64,
|
||||
end_of_scope: u64,
|
||||
segment_requests: &'seg_reqs [(u64, u64)],
|
||||
) -> Result<NakPduCreator<'seg_reqs>, PduError> {
|
||||
) -> Result<NakPduCreator, PduError> {
|
||||
let mut passed_segment_requests = None;
|
||||
if !segment_requests.is_empty() {
|
||||
passed_segment_requests = Some(SegmentRequests::U64Pairs(segment_requests));
|
||||
@ -97,7 +97,7 @@ impl<'seg_reqs> NakPduCreator<'seg_reqs> {
|
||||
start_of_scope: u64,
|
||||
end_of_scope: u64,
|
||||
segment_requests: Option<SegmentRequests<'seg_reqs>>,
|
||||
) -> Result<NakPduCreator<'seg_reqs>, PduError> {
|
||||
) -> Result<NakPduCreator, PduError> {
|
||||
// Force correct direction flag.
|
||||
pdu_header.pdu_conf.direction = Direction::TowardsSender;
|
||||
if let Some(ref segment_requests) = segment_requests {
|
||||
@ -269,7 +269,7 @@ impl SegReqFromBytes for u64 {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Iterator for SegmentRequestIter<'_, T>
|
||||
impl<'a, T> Iterator for SegmentRequestIter<'a, T>
|
||||
where
|
||||
T: SegReqFromBytes,
|
||||
{
|
||||
@ -282,8 +282,8 @@ where
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq<SegmentRequests<'a>> for SegmentRequestIter<'_, u32> {
|
||||
fn eq(&self, other: &SegmentRequests<'a>) -> bool {
|
||||
impl<'a, 'b> PartialEq<SegmentRequests<'a>> for SegmentRequestIter<'b, u32> {
|
||||
fn eq(&self, other: &SegmentRequests) -> bool {
|
||||
match other {
|
||||
SegmentRequests::U32Pairs(pairs) => self.compare_pairs(pairs),
|
||||
SegmentRequests::U64Pairs(pairs) => {
|
||||
@ -296,8 +296,8 @@ impl<'a> PartialEq<SegmentRequests<'a>> for SegmentRequestIter<'_, u32> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq<SegmentRequests<'a>> for SegmentRequestIter<'_, u64> {
|
||||
fn eq(&self, other: &SegmentRequests<'a>) -> bool {
|
||||
impl<'a, 'b> PartialEq<SegmentRequests<'a>> for SegmentRequestIter<'b, u64> {
|
||||
fn eq(&self, other: &SegmentRequests) -> bool {
|
||||
match other {
|
||||
SegmentRequests::U32Pairs(pairs) => {
|
||||
if pairs.is_empty() && self.seq_req_raw.is_empty() {
|
||||
@ -310,7 +310,7 @@ impl<'a> PartialEq<SegmentRequests<'a>> for SegmentRequestIter<'_, u64> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> SegmentRequestIter<'_, T>
|
||||
impl<'a, T> SegmentRequestIter<'a, T>
|
||||
where
|
||||
T: SegReqFromBytes + PartialEq,
|
||||
{
|
||||
@ -374,11 +374,11 @@ impl CfdpPdu for NakPduReader<'_> {
|
||||
}
|
||||
|
||||
impl<'seg_reqs> NakPduReader<'seg_reqs> {
|
||||
pub fn new(buf: &'seg_reqs [u8]) -> Result<NakPduReader<'seg_reqs>, PduError> {
|
||||
pub fn new(buf: &'seg_reqs [u8]) -> Result<NakPduReader, PduError> {
|
||||
Self::from_bytes(buf)
|
||||
}
|
||||
|
||||
pub fn from_bytes(buf: &'seg_reqs [u8]) -> Result<NakPduReader<'seg_reqs>, PduError> {
|
||||
pub fn from_bytes(buf: &'seg_reqs [u8]) -> Result<NakPduReader, PduError> {
|
||||
let (pdu_header, mut current_idx) = PduHeader::from_bytes(buf)?;
|
||||
let full_len_without_crc = pdu_header.verify_length_and_checksum(buf)?;
|
||||
// Minimum length of 9: 1 byte directive field and start and end of scope for normal file
|
||||
@ -474,7 +474,7 @@ impl<'seg_reqs> NakPduReader<'seg_reqs> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> PartialEq<NakPduCreator<'a>> for NakPduReader<'_> {
|
||||
impl<'a, 'b> PartialEq<NakPduCreator<'a>> for NakPduReader<'b> {
|
||||
fn eq(&self, other: &NakPduCreator<'a>) -> bool {
|
||||
if self.pdu_header() != other.pdu_header()
|
||||
|| self.end_of_scope() != other.end_of_scope()
|
||||
@ -751,7 +751,7 @@ mod tests {
|
||||
if let PduError::InvalidStartOrEndOfScopeValue = error {
|
||||
assert_eq!(
|
||||
error.to_string(),
|
||||
"invalid start or end of scope value for NAK PDU"
|
||||
"invalid start or end of scope for NAK PDU"
|
||||
);
|
||||
} else {
|
||||
panic!("unexpected error {error}");
|
||||
@ -796,7 +796,7 @@ mod tests {
|
||||
nak_vec[nak_pdu.len_written() - 1] -= 1;
|
||||
let nak_pdu_deser = NakPduReader::new(&nak_vec);
|
||||
assert!(nak_pdu_deser.is_err());
|
||||
if let Err(PduError::Checksum(raw)) = nak_pdu_deser {
|
||||
if let Err(PduError::ChecksumError(raw)) = nak_pdu_deser {
|
||||
assert_eq!(
|
||||
raw,
|
||||
u16::from_be_bytes(nak_vec[nak_pdu.len_written() - 2..].try_into().unwrap())
|
||||
|
||||
@ -15,8 +15,6 @@ 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;
|
||||
@ -153,14 +151,14 @@ pub struct Tlv<'data> {
|
||||
}
|
||||
|
||||
impl<'data> Tlv<'data> {
|
||||
pub fn new(tlv_type: TlvType, data: &[u8]) -> Result<Tlv, TlvLvDataTooLargeError> {
|
||||
pub fn new(tlv_type: TlvType, data: &[u8]) -> Result<Tlv, TlvLvError> {
|
||||
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, TlvLvDataTooLargeError> {
|
||||
pub fn new_with_custom_type(tlv_type: u8, data: &[u8]) -> Result<Tlv, TlvLvError> {
|
||||
Ok(Tlv {
|
||||
tlv_type_field: TlvTypeField::Custom(tlv_type),
|
||||
lv: Lv::new(data)?,
|
||||
@ -179,7 +177,7 @@ impl<'data> Tlv<'data> {
|
||||
/// 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>, ByteConversionError> {
|
||||
pub fn from_bytes(buf: &'data [u8]) -> Result<Tlv<'data>, TlvLvError> {
|
||||
generic_len_check_deserialization(buf, MIN_TLV_LEN)?;
|
||||
let mut tlv = Self {
|
||||
tlv_type_field: TlvTypeField::from(buf[0]),
|
||||
@ -196,7 +194,6 @@ impl<'data> Tlv<'data> {
|
||||
pub fn raw_data(&self) -> Option<&[u8]> {
|
||||
self.lv.raw_data()
|
||||
}
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
pub fn to_owned(&self) -> TlvOwned {
|
||||
TlvOwned {
|
||||
@ -273,15 +270,6 @@ pub mod alloc_mod {
|
||||
data: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
@ -374,8 +362,11 @@ impl EntityIdTlv {
|
||||
Self::len_check(buf)?;
|
||||
self.entity_id
|
||||
.write_to_be_bytes(&mut buf[2..2 + self.entity_id.size()])?;
|
||||
// Can't fail.
|
||||
Ok(Tlv::new(TlvType::EntityId, &buf[2..2 + self.entity_id.size()]).unwrap())
|
||||
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"),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@ -398,26 +389,24 @@ impl GenericTlv for EntityIdTlv {
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<Tlv<'_>> for EntityIdTlv {
|
||||
impl<'data> TryFrom<Tlv<'data>> for EntityIdTlv {
|
||||
type Error = TlvLvError;
|
||||
|
||||
fn try_from(value: Tlv) -> Result<Self, TlvLvError> {
|
||||
fn try_from(value: Tlv) -> Result<Self, Self::Error> {
|
||||
match value.tlv_type_field {
|
||||
TlvTypeField::Standard(tlv_type) => {
|
||||
if tlv_type != TlvType::EntityId {
|
||||
return Err(InvalidTlvTypeFieldError {
|
||||
return Err(TlvLvError::InvalidTlvTypeField {
|
||||
found: tlv_type as u8,
|
||||
expected: Some(TlvType::EntityId as u8),
|
||||
}
|
||||
.into());
|
||||
});
|
||||
}
|
||||
}
|
||||
TlvTypeField::Custom(val) => {
|
||||
return Err(InvalidTlvTypeFieldError {
|
||||
return Err(TlvLvError::InvalidTlvTypeField {
|
||||
found: val,
|
||||
expected: Some(TlvType::EntityId as u8),
|
||||
}
|
||||
.into());
|
||||
});
|
||||
}
|
||||
}
|
||||
let len_value = value.value().len();
|
||||
@ -848,16 +837,13 @@ impl GenericTlv for FilestoreResponseTlv<'_, '_, '_> {
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
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(InvalidTlvTypeFieldError {
|
||||
return Err(TlvLvError::InvalidTlvTypeField {
|
||||
found: tlv_type as u8,
|
||||
expected: Some(expected_tlv_type as u8),
|
||||
});
|
||||
@ -1052,14 +1038,14 @@ mod tests {
|
||||
let tlv_res = Tlv::new(TlvType::MsgToUser, &buf_too_large);
|
||||
assert!(tlv_res.is_err());
|
||||
let error = tlv_res.unwrap_err();
|
||||
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"
|
||||
);
|
||||
}
|
||||
if let TlvLvError::DataTooLarge(size) = error {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1369,8 +1355,7 @@ mod tests {
|
||||
let error = EntityIdTlv::try_from(msg_to_user_tlv);
|
||||
assert!(error.is_err());
|
||||
let error = error.unwrap_err();
|
||||
if let TlvLvError::InvalidTlvTypeField(InvalidTlvTypeFieldError { found, expected }) = error
|
||||
{
|
||||
if let TlvLvError::InvalidTlvTypeField { found, expected } = error {
|
||||
assert_eq!(found, TlvType::MsgToUser as u8);
|
||||
assert_eq!(expected, Some(TlvType::EntityId as u8));
|
||||
assert_eq!(
|
||||
|
||||
@ -1,11 +1,6 @@
|
||||
//! Abstractions for the Message to User CFDP TLV subtype.
|
||||
#[cfg(feature = "alloc")]
|
||||
use super::TlvOwned;
|
||||
use super::{GenericTlv, ReadableTlv, Tlv, TlvLvError, TlvType, TlvTypeField, WritableTlv};
|
||||
use crate::{
|
||||
cfdp::{InvalidTlvTypeFieldError, TlvLvDataTooLargeError},
|
||||
ByteConversionError,
|
||||
};
|
||||
use crate::ByteConversionError;
|
||||
use delegate::delegate;
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
@ -15,7 +10,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>, TlvLvDataTooLargeError> {
|
||||
pub fn new(value: &'data [u8]) -> Result<MsgToUserTlv<'data>, TlvLvError> {
|
||||
Ok(Self {
|
||||
tlv: Tlv::new(TlvType::MsgToUser, value)?,
|
||||
})
|
||||
@ -65,38 +60,21 @@ impl<'data> MsgToUserTlv<'data> {
|
||||
match msg_to_user.tlv.tlv_type_field() {
|
||||
TlvTypeField::Standard(tlv_type) => {
|
||||
if tlv_type != TlvType::MsgToUser {
|
||||
return Err(InvalidTlvTypeFieldError {
|
||||
return Err(TlvLvError::InvalidTlvTypeField {
|
||||
found: tlv_type as u8,
|
||||
expected: Some(TlvType::MsgToUser as u8),
|
||||
}
|
||||
.into());
|
||||
});
|
||||
}
|
||||
}
|
||||
TlvTypeField::Custom(raw) => {
|
||||
return Err(InvalidTlvTypeFieldError {
|
||||
return Err(TlvLvError::InvalidTlvTypeField {
|
||||
found: raw,
|
||||
expected: Some(TlvType::MsgToUser as u8),
|
||||
}
|
||||
.into());
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(msg_to_user)
|
||||
}
|
||||
|
||||
pub fn to_tlv(&self) -> Tlv<'data> {
|
||||
self.tlv
|
||||
}
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
pub fn to_owned(&self) -> TlvOwned {
|
||||
self.tlv.to_owned()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<MsgToUserTlv<'a>> for Tlv<'a> {
|
||||
fn from(value: MsgToUserTlv<'a>) -> Tlv<'a> {
|
||||
value.to_tlv()
|
||||
}
|
||||
}
|
||||
|
||||
impl WritableTlv for MsgToUserTlv<'_> {
|
||||
@ -161,40 +139,6 @@ 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];
|
||||
@ -210,9 +154,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(inner) = error {
|
||||
assert_eq!(inner.found, TlvType::FlowLabel as u8);
|
||||
assert_eq!(inner.expected, Some(TlvType::MsgToUser as u8));
|
||||
if let TlvLvError::InvalidTlvTypeField { found, expected } = error {
|
||||
assert_eq!(found, TlvType::FlowLabel as u8);
|
||||
assert_eq!(expected, Some(TlvType::MsgToUser as u8));
|
||||
} else {
|
||||
panic!("Wrong error type returned: {:?}", error);
|
||||
}
|
||||
|
||||
11
src/crc.rs
11
src/crc.rs
@ -1,11 +0,0 @@
|
||||
/// 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);
|
||||
105
src/ecss/mod.rs
105
src/ecss/mod.rs
@ -3,17 +3,16 @@
|
||||
//!
|
||||
//! You can find the PUS telecommand types in the [tc] module and the the PUS telemetry
|
||||
//! types inside the [tm] module.
|
||||
use crate::{
|
||||
crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE},
|
||||
ByteConversionError, CcsdsPacket,
|
||||
};
|
||||
use crate::{ByteConversionError, CcsdsPacket, CRC_CCITT_FALSE};
|
||||
#[cfg(feature = "alloc")]
|
||||
use alloc::vec::Vec;
|
||||
use core::fmt::Debug;
|
||||
use core::fmt::{Debug, Display, Formatter};
|
||||
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;
|
||||
@ -149,19 +148,50 @@ pub enum PfcReal {
|
||||
DoubleMilStd = 4,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
||||
pub enum PusError {
|
||||
#[error("PUS version {0:?} not supported")]
|
||||
VersionNotSupported(PusVersion),
|
||||
#[error("checksum verification for crc16 {0:#06x} failed")]
|
||||
ChecksumFailure(u16),
|
||||
/// CRC16 needs to be calculated first
|
||||
//#[error("crc16 was not calculated")]
|
||||
//CrcCalculationMissing,
|
||||
#[error("pus error: {0}")]
|
||||
ByteConversion(#[from] ByteConversionError),
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
/// Generic trait to describe common attributes for both PUS Telecommands (TC) and PUS Telemetry
|
||||
@ -173,7 +203,7 @@ pub trait PusPacket: CcsdsPacket {
|
||||
fn service(&self) -> u8;
|
||||
fn subservice(&self) -> u8;
|
||||
fn user_data(&self) -> &[u8];
|
||||
fn opt_crc16(&self) -> Option<u16>;
|
||||
fn crc16(&self) -> Option<u16>;
|
||||
}
|
||||
|
||||
pub(crate) fn crc_from_raw_data(raw_data: &[u8]) -> Result<u16, ByteConversionError> {
|
||||
@ -210,7 +240,7 @@ pub(crate) fn user_data_from_raw(
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_crc16_ccitt_false_from_raw_to_pus_error(
|
||||
pub(crate) fn verify_crc16_ccitt_false_from_raw_to_pus_error(
|
||||
raw_data: &[u8],
|
||||
crc16: u16,
|
||||
) -> Result<(), PusError> {
|
||||
@ -219,15 +249,6 @@ pub fn verify_crc16_ccitt_false_from_raw_to_pus_error(
|
||||
.ok_or(PusError::ChecksumFailure(crc16))
|
||||
}
|
||||
|
||||
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))
|
||||
}
|
||||
|
||||
pub(crate) fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
|
||||
let mut digest = CRC_CCITT_FALSE.digest();
|
||||
digest.update(raw_data);
|
||||
@ -237,15 +258,6 @@ pub(crate) fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
pub(crate) 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! ccsds_impl {
|
||||
() => {
|
||||
delegate!(to self.sp_header {
|
||||
@ -370,34 +382,7 @@ generic_ecss_enum_typedefs_and_from_impls! {
|
||||
/// on the serialization of those packets.
|
||||
pub trait WritablePusPacket {
|
||||
fn len_written(&self) -> usize;
|
||||
|
||||
/// Writes the packet to the given slice without writing the CRC.
|
||||
///
|
||||
/// The returned size is the written size WITHOUT the CRC.
|
||||
fn write_to_bytes_no_crc(&self, slice: &mut [u8]) -> Result<usize, PusError>;
|
||||
|
||||
/// First uses [Self::write_to_bytes_no_crc] 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.
|
||||
fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
let mut curr_idx = self.write_to_bytes_no_crc(slice)?;
|
||||
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_crc] 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.
|
||||
fn write_to_bytes_crc_no_table(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
let mut curr_idx = self.write_to_bytes_no_crc(slice)?;
|
||||
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)
|
||||
}
|
||||
|
||||
fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError>;
|
||||
#[cfg(feature = "alloc")]
|
||||
fn to_vec(&self) -> Result<Vec<u8>, PusError> {
|
||||
// This is the correct way to do this. See
|
||||
|
||||
436
src/ecss/tc.rs
436
src/ecss/tc.rs
@ -33,26 +33,23 @@
|
||||
//! assert_eq!(pus_tc.subservice(), 1);
|
||||
//! assert_eq!(pus_tc.apid(), 0x02);
|
||||
//! ```
|
||||
use crate::crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE};
|
||||
use crate::ecss::{
|
||||
ccsds_impl, crc_from_raw_data, sp_header_impls, user_data_from_raw,
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error, CrcType, PusError, PusPacket, PusVersion,
|
||||
WritablePusPacket,
|
||||
};
|
||||
use crate::SpHeader;
|
||||
use crate::{ByteConversionError, CcsdsPacket, PacketType, SequenceFlags, CCSDS_HEADER_LEN};
|
||||
use crate::{SpHeader, CRC_CCITT_FALSE};
|
||||
use core::mem::size_of;
|
||||
use delegate::delegate;
|
||||
use num_enum::{IntoPrimitive, TryFromPrimitive};
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
use zerocopy::{FromBytes, IntoBytes};
|
||||
use zerocopy::AsBytes;
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use super::verify_crc16_ccitt_false_from_raw_to_pus_error_no_table;
|
||||
|
||||
/// PUS C secondary header length is fixed
|
||||
pub const PUC_TC_SECONDARY_HEADER_LEN: usize = size_of::<zc::PusTcSecondaryHeader>();
|
||||
pub const PUS_TC_MIN_LEN_WITHOUT_APP_DATA: usize =
|
||||
@ -89,9 +86,9 @@ pub trait GenericPusTcSecondaryHeader {
|
||||
pub mod zc {
|
||||
use crate::ecss::tc::GenericPusTcSecondaryHeader;
|
||||
use crate::ecss::{PusError, PusVersion};
|
||||
use zerocopy::{FromBytes, Immutable, IntoBytes, NetworkEndian, Unaligned, U16};
|
||||
use zerocopy::{AsBytes, FromBytes, FromZeroes, NetworkEndian, Unaligned, U16};
|
||||
|
||||
#[derive(FromBytes, IntoBytes, Immutable, Unaligned)]
|
||||
#[derive(FromZeroes, FromBytes, AsBytes, Unaligned)]
|
||||
#[repr(C)]
|
||||
pub struct PusTcSecondaryHeader {
|
||||
version_ack: u8,
|
||||
@ -118,7 +115,7 @@ pub mod zc {
|
||||
impl GenericPusTcSecondaryHeader for PusTcSecondaryHeader {
|
||||
#[inline]
|
||||
fn pus_version(&self) -> PusVersion {
|
||||
PusVersion::try_from((self.version_ack >> 4) & 0b1111).unwrap_or(PusVersion::Invalid)
|
||||
PusVersion::try_from(self.version_ack >> 4 & 0b1111).unwrap_or(PusVersion::Invalid)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -141,6 +138,16 @@ pub mod zc {
|
||||
self.source_id.get()
|
||||
}
|
||||
}
|
||||
|
||||
impl PusTcSecondaryHeader {
|
||||
pub fn write_to_bytes(&self, slice: &mut [u8]) -> Option<()> {
|
||||
self.write_to(slice)
|
||||
}
|
||||
|
||||
pub fn from_bytes(slice: &[u8]) -> Option<Self> {
|
||||
Self::read_from(slice)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
|
||||
@ -242,13 +249,13 @@ impl<'app_data> PusTcCreator<'app_data> {
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `sp_header` - Space packet header information. The correct packet type and the secondary
|
||||
/// header flag are set correctly by the constructor.
|
||||
/// header flag are set correctly by the constructor.
|
||||
/// * `sec_header` - Information contained in the data field header, including the service
|
||||
/// and subservice type
|
||||
/// and subservice type
|
||||
/// * `app_data` - Custom application data
|
||||
/// * `set_ccsds_len` - Can be used to automatically update the CCSDS space packet data length
|
||||
/// field. If this is not set to true, [Self::update_ccsds_data_len] can be called to set
|
||||
/// the correct value to this field manually
|
||||
/// field. If this is not set to true, [Self::update_ccsds_data_len] can be called to set
|
||||
/// the correct value to this field manually
|
||||
#[inline]
|
||||
pub fn new(
|
||||
mut sp_header: SpHeader,
|
||||
@ -345,17 +352,6 @@ impl<'app_data> PusTcCreator<'app_data> {
|
||||
digest.finalize()
|
||||
}
|
||||
|
||||
/// This function calculates and returns the CRC16 for the current packet.
|
||||
pub fn calc_own_crc16_no_table(&self) -> u16 {
|
||||
let mut digest = CRC_CCITT_FALSE_NO_TABLE.digest();
|
||||
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
|
||||
digest.update(sph_zc.as_bytes());
|
||||
let pus_tc_header = zc::PusTcSecondaryHeader::try_from(self.sec_header).unwrap();
|
||||
digest.update(pus_tc_header.as_bytes());
|
||||
digest.update(self.app_data);
|
||||
digest.finalize()
|
||||
}
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
pub fn append_to_vec(&self, vec: &mut Vec<u8>) -> usize {
|
||||
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
|
||||
@ -372,49 +368,6 @@ impl<'app_data> PusTcCreator<'app_data> {
|
||||
vec.extend_from_slice(&digest.finalize().to_be_bytes());
|
||||
appended_len
|
||||
}
|
||||
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
pub fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, ByteConversionError> {
|
||||
let writer_unfinalized = self.common_write(slice)?;
|
||||
Ok(writer_unfinalized.finalize())
|
||||
}
|
||||
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
pub fn write_to_bytes_crc_no_table(
|
||||
&self,
|
||||
slice: &mut [u8],
|
||||
) -> Result<usize, ByteConversionError> {
|
||||
let writer_unfinalized = self.common_write(slice)?;
|
||||
Ok(writer_unfinalized.finalize_crc_no_table())
|
||||
}
|
||||
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
pub fn write_to_bytes_no_crc(&self, slice: &mut [u8]) -> Result<usize, ByteConversionError> {
|
||||
let writer_unfinalized = self.common_write(slice)?;
|
||||
Ok(writer_unfinalized.finalize_no_crc())
|
||||
}
|
||||
|
||||
fn common_write<'a>(
|
||||
&self,
|
||||
slice: &'a mut [u8],
|
||||
) -> Result<PusTcCreatorWithReservedAppData<'a>, ByteConversionError> {
|
||||
if self.len_written() > slice.len() {
|
||||
return Err(ByteConversionError::ToSliceTooSmall {
|
||||
found: slice.len(),
|
||||
expected: self.len_written(),
|
||||
});
|
||||
}
|
||||
let mut writer_unfinalized = PusTcCreatorWithReservedAppData::write_to_bytes_partially(
|
||||
slice,
|
||||
self.sp_header,
|
||||
self.sec_header,
|
||||
self.app_data.len(),
|
||||
)?;
|
||||
writer_unfinalized
|
||||
.app_data_mut()
|
||||
.copy_from_slice(self.app_data);
|
||||
Ok(writer_unfinalized)
|
||||
}
|
||||
}
|
||||
|
||||
impl WritablePusPacket for PusTcCreator<'_> {
|
||||
@ -424,16 +377,32 @@ impl WritablePusPacket for PusTcCreator<'_> {
|
||||
}
|
||||
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
fn write_to_bytes_no_crc(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
Ok(Self::write_to_bytes_no_crc(self, slice)?)
|
||||
}
|
||||
|
||||
fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
Ok(Self::write_to_bytes(self, slice)?)
|
||||
}
|
||||
let mut curr_idx = 0;
|
||||
let tc_header_len = size_of::<zc::PusTcSecondaryHeader>();
|
||||
let total_size = self.len_written();
|
||||
if total_size > slice.len() {
|
||||
return Err(ByteConversionError::ToSliceTooSmall {
|
||||
found: slice.len(),
|
||||
expected: total_size,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
self.sp_header.write_to_be_bytes(slice)?;
|
||||
curr_idx += CCSDS_HEADER_LEN;
|
||||
let sec_header = zc::PusTcSecondaryHeader::try_from(self.sec_header).unwrap();
|
||||
sec_header
|
||||
.write_to_bytes(&mut slice[curr_idx..curr_idx + tc_header_len])
|
||||
.ok_or(ByteConversionError::ZeroCopyToError)?;
|
||||
|
||||
fn write_to_bytes_crc_no_table(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
Ok(Self::write_to_bytes_crc_no_table(self, slice)?)
|
||||
curr_idx += tc_header_len;
|
||||
slice[curr_idx..curr_idx + self.app_data.len()].copy_from_slice(self.app_data);
|
||||
curr_idx += self.app_data.len();
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
@ -457,7 +426,7 @@ impl PusPacket for PusTcCreator<'_> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn opt_crc16(&self) -> Option<u16> {
|
||||
fn crc16(&self) -> Option<u16> {
|
||||
Some(self.calc_own_crc16())
|
||||
}
|
||||
}
|
||||
@ -479,133 +448,6 @@ impl GenericPusTcSecondaryHeader for PusTcCreator<'_> {
|
||||
|
||||
impl IsPusTelecommand for PusTcCreator<'_> {}
|
||||
|
||||
/// A specialized variant of [PusTcCreator] designed for efficiency when handling large source
|
||||
/// data.
|
||||
///
|
||||
/// Unlike [PusTcCreator], this type does not require the user to provide the application data
|
||||
/// as a separate slice. Instead, it allows writing the application data directly into the provided
|
||||
/// serialization buffer. This eliminates the need for an intermediate buffer and the associated
|
||||
/// memory copy, improving performance, particularly when working with large payloads.
|
||||
///
|
||||
/// **Important:** The total length of the source data must be known and specified in advance
|
||||
/// to ensure correct serialization behavior.
|
||||
///
|
||||
/// Note that this abstraction intentionally omits certain trait implementations that are available
|
||||
/// on [PusTcCreator], as they are not applicable in this optimized usage pattern.
|
||||
pub struct PusTcCreatorWithReservedAppData<'buf> {
|
||||
buf: &'buf mut [u8],
|
||||
app_data_offset: usize,
|
||||
full_len: usize,
|
||||
}
|
||||
|
||||
impl<'buf> PusTcCreatorWithReservedAppData<'buf> {
|
||||
/// Generates a new instance with reserved space for the user application data.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `sp_header` - Space packet header information. The correct packet type and the secondary
|
||||
/// header flag are set correctly by the constructor.
|
||||
/// * `sec_header` - Information contained in the secondary header, including the service
|
||||
/// and subservice type
|
||||
/// * `app_data_len` - Custom application data length
|
||||
#[inline]
|
||||
pub fn new(
|
||||
buf: &'buf mut [u8],
|
||||
mut sp_header: SpHeader,
|
||||
sec_header: PusTcSecondaryHeader,
|
||||
app_data_len: usize,
|
||||
) -> Result<Self, ByteConversionError> {
|
||||
sp_header.set_packet_type(PacketType::Tc);
|
||||
sp_header.set_sec_header_flag();
|
||||
let len_written = PUS_TC_MIN_LEN_WITHOUT_APP_DATA + app_data_len;
|
||||
if len_written > buf.len() {
|
||||
return Err(ByteConversionError::ToSliceTooSmall {
|
||||
found: buf.len(),
|
||||
expected: len_written,
|
||||
});
|
||||
}
|
||||
sp_header.data_len = len_written as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;
|
||||
Self::write_to_bytes_partially(buf, sp_header, sec_header, app_data_len)
|
||||
}
|
||||
|
||||
fn write_to_bytes_partially(
|
||||
buf: &'buf mut [u8],
|
||||
sp_header: SpHeader,
|
||||
sec_header: PusTcSecondaryHeader,
|
||||
app_data_len: usize,
|
||||
) -> Result<Self, ByteConversionError> {
|
||||
let mut curr_idx = 0;
|
||||
sp_header.write_to_be_bytes(&mut buf[0..CCSDS_HEADER_LEN])?;
|
||||
curr_idx += CCSDS_HEADER_LEN;
|
||||
let sec_header_len = size_of::<zc::PusTcSecondaryHeader>();
|
||||
let sec_header_zc = zc::PusTcSecondaryHeader::try_from(sec_header).unwrap();
|
||||
sec_header_zc
|
||||
.write_to(&mut buf[curr_idx..curr_idx + sec_header_len])
|
||||
.map_err(|_| ByteConversionError::ZeroCopyToError)?;
|
||||
curr_idx += sec_header_len;
|
||||
let app_data_offset = curr_idx;
|
||||
curr_idx += app_data_len;
|
||||
Ok(Self {
|
||||
buf,
|
||||
app_data_offset,
|
||||
full_len: curr_idx + 2,
|
||||
})
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub const fn len_written(&self) -> usize {
|
||||
self.full_len
|
||||
}
|
||||
|
||||
/// Mutable access to the application data buffer.
|
||||
#[inline]
|
||||
pub fn app_data_mut(&mut self) -> &mut [u8] {
|
||||
&mut self.buf[self.app_data_offset..self.full_len - 2]
|
||||
}
|
||||
|
||||
/// Access to the source data buffer.
|
||||
#[inline]
|
||||
pub fn app_data(&self) -> &[u8] {
|
||||
&self.buf[self.app_data_offset..self.full_len - 2]
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn app_data_len(&self) -> usize {
|
||||
self.full_len - 2 - self.app_data_offset
|
||||
}
|
||||
|
||||
/// Finalize the TC packet by calculating and writing the CRC16.
|
||||
///
|
||||
/// Returns the full packet length.
|
||||
pub fn finalize(self) -> usize {
|
||||
let mut digest = CRC_CCITT_FALSE.digest();
|
||||
digest.update(&self.buf[0..self.full_len - 2]);
|
||||
self.buf[self.full_len - 2..self.full_len]
|
||||
.copy_from_slice(&digest.finalize().to_be_bytes());
|
||||
self.full_len
|
||||
}
|
||||
|
||||
/// Finalize the TC packet by calculating and writing the CRC16 using a table-less
|
||||
/// implementation.
|
||||
///
|
||||
/// Returns the full packet length.
|
||||
pub fn finalize_crc_no_table(self) -> usize {
|
||||
let mut digest = CRC_CCITT_FALSE_NO_TABLE.digest();
|
||||
digest.update(&self.buf[0..self.full_len - 2]);
|
||||
self.buf[self.full_len - 2..self.full_len]
|
||||
.copy_from_slice(&digest.finalize().to_be_bytes());
|
||||
self.full_len
|
||||
}
|
||||
|
||||
/// Finalize the TC packet without writing the CRC16.
|
||||
///
|
||||
/// Returns the length WITHOUT the CRC16.
|
||||
#[inline]
|
||||
pub fn finalize_no_crc(self) -> usize {
|
||||
self.full_len - 2
|
||||
}
|
||||
}
|
||||
|
||||
/// This class can be used to read a PUS TC telecommand from raw memory.
|
||||
///
|
||||
/// This class also derives the [serde::Serialize] and [serde::Deserialize] trait if the
|
||||
@ -633,22 +475,7 @@ impl<'raw_data> PusTcReader<'raw_data> {
|
||||
/// Create a [PusTcReader] instance from a raw slice. On success, it returns a tuple containing
|
||||
/// the instance and the found byte length of the packet. This function also performs a CRC
|
||||
/// check and will return an appropriate [PusError] if the check fails.
|
||||
pub fn new(slice: &'raw_data [u8]) -> Result<Self, PusError> {
|
||||
let pus_tc = Self::new_no_crc_check(slice)?;
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error(pus_tc.raw_data(), pus_tc.crc16())?;
|
||||
Ok(pus_tc)
|
||||
}
|
||||
|
||||
/// Similar to [PusTcReader::new], but uses a table-less CRC16 algorithm which can reduce
|
||||
/// binary size and memory usage.
|
||||
pub fn new_crc_no_table(slice: &'raw_data [u8]) -> Result<Self, PusError> {
|
||||
let pus_tc = Self::new_no_crc_check(slice)?;
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error_no_table(pus_tc.raw_data(), pus_tc.crc16())?;
|
||||
Ok(pus_tc)
|
||||
}
|
||||
|
||||
/// Creates a new instance without performing a CRC check.
|
||||
pub fn new_no_crc_check(slice: &'raw_data [u8]) -> Result<Self, PusError> {
|
||||
pub fn new(slice: &'raw_data [u8]) -> Result<(Self, usize), PusError> {
|
||||
let raw_data_len = slice.len();
|
||||
if raw_data_len < PUS_TC_MIN_LEN_WITHOUT_APP_DATA {
|
||||
return Err(ByteConversionError::FromSliceTooSmall {
|
||||
@ -675,19 +502,21 @@ impl<'raw_data> PusTcReader<'raw_data> {
|
||||
}
|
||||
.into());
|
||||
}
|
||||
let sec_header = zc::PusTcSecondaryHeader::read_from_bytes(
|
||||
let sec_header = zc::PusTcSecondaryHeader::from_bytes(
|
||||
&slice[current_idx..current_idx + PUC_TC_SECONDARY_HEADER_LEN],
|
||||
)
|
||||
.map_err(|_| ByteConversionError::ZeroCopyFromError)?;
|
||||
.ok_or(ByteConversionError::ZeroCopyFromError)?;
|
||||
current_idx += PUC_TC_SECONDARY_HEADER_LEN;
|
||||
let raw_data = &slice[0..total_len];
|
||||
Ok(Self {
|
||||
let pus_tc = Self {
|
||||
sp_header,
|
||||
sec_header: PusTcSecondaryHeader::try_from(sec_header).unwrap(),
|
||||
raw_data,
|
||||
app_data: user_data_from_raw(current_idx, total_len, slice)?,
|
||||
crc16: crc_from_raw_data(raw_data)?,
|
||||
})
|
||||
};
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error(raw_data, pus_tc.crc16)?;
|
||||
Ok((pus_tc, total_len))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -709,11 +538,6 @@ impl<'raw_data> PusTcReader<'raw_data> {
|
||||
pub fn sp_header(&self) -> &SpHeader {
|
||||
&self.sp_header
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn crc16(&self) -> u16 {
|
||||
self.crc16
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for PusTcReader<'_> {
|
||||
@ -743,7 +567,7 @@ impl PusPacket for PusTcReader<'_> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn opt_crc16(&self) -> Option<u16> {
|
||||
fn crc16(&self) -> Option<u16> {
|
||||
Some(self.crc16)
|
||||
}
|
||||
}
|
||||
@ -783,6 +607,8 @@ impl PartialEq<PusTcReader<'_>> for PusTcCreator<'_> {
|
||||
|
||||
#[cfg(all(test, feature = "std"))]
|
||||
mod tests {
|
||||
use std::error::Error;
|
||||
|
||||
use super::*;
|
||||
use crate::ecss::PusVersion::PusC;
|
||||
use crate::ecss::{PusError, PusPacket, WritablePusPacket};
|
||||
@ -824,74 +650,11 @@ mod tests {
|
||||
.expect("Error writing TC to buffer");
|
||||
assert_eq!(size, 13);
|
||||
assert_eq!(
|
||||
pus_tc.opt_crc16().unwrap(),
|
||||
pus_tc.crc16().unwrap(),
|
||||
u16::from_be_bytes(test_buf[size - 2..size].try_into().unwrap())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_with_trait_1() {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let mut test_buf: [u8; 32] = [0; 32];
|
||||
let size = WritablePusPacket::write_to_bytes(&pus_tc, test_buf.as_mut_slice())
|
||||
.expect("Error writing TC to buffer");
|
||||
assert_eq!(size, 13);
|
||||
assert_eq!(
|
||||
pus_tc.opt_crc16().unwrap(),
|
||||
u16::from_be_bytes(test_buf[size - 2..size].try_into().unwrap())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_with_trait_2() {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let mut test_buf: [u8; 32] = [0; 32];
|
||||
let size = WritablePusPacket::write_to_bytes_crc_no_table(&pus_tc, test_buf.as_mut_slice())
|
||||
.expect("Error writing TC to buffer");
|
||||
assert_eq!(size, 13);
|
||||
assert_eq!(
|
||||
pus_tc.opt_crc16().unwrap(),
|
||||
u16::from_be_bytes(test_buf[size - 2..size].try_into().unwrap())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_crc_no_table() {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let mut test_buf: [u8; 32] = [0; 32];
|
||||
let size = pus_tc
|
||||
.write_to_bytes_crc_no_table(test_buf.as_mut_slice())
|
||||
.expect("error writing tc to buffer");
|
||||
assert_eq!(size, 13);
|
||||
assert_eq!(
|
||||
pus_tc.opt_crc16().unwrap(),
|
||||
u16::from_be_bytes(test_buf[size - 2..size].try_into().unwrap())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_no_crc() {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let mut test_buf: [u8; 32] = [0; 32];
|
||||
let size = pus_tc
|
||||
.write_to_bytes_no_crc(test_buf.as_mut_slice())
|
||||
.expect("error writing tc to buffer");
|
||||
assert_eq!(size, 11);
|
||||
assert_eq!(test_buf[11], 0);
|
||||
assert_eq!(test_buf[12], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_no_crc_with_trait() {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let mut test_buf: [u8; 32] = [0; 32];
|
||||
let size = WritablePusPacket::write_to_bytes_no_crc(&pus_tc, test_buf.as_mut_slice())
|
||||
.expect("error writing tc to buffer");
|
||||
assert_eq!(size, 11);
|
||||
assert_eq!(test_buf[11], 0);
|
||||
assert_eq!(test_buf[12], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization() {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
@ -900,48 +663,9 @@ mod tests {
|
||||
.write_to_bytes(test_buf.as_mut_slice())
|
||||
.expect("Error writing TC to buffer");
|
||||
assert_eq!(size, 13);
|
||||
let tc_from_raw =
|
||||
let (tc_from_raw, size) =
|
||||
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
|
||||
assert_eq!(tc_from_raw.total_len(), 13);
|
||||
verify_test_tc_with_reader(&tc_from_raw, false, 13);
|
||||
assert!(tc_from_raw.user_data().is_empty());
|
||||
verify_test_tc_raw(&test_buf);
|
||||
verify_crc_no_app_data(&test_buf);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization_alt_ctor() {
|
||||
let sph = SpHeader::new_for_unseg_tc_checked(0x02, 0x34, 0).unwrap();
|
||||
let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
|
||||
let mut test_buf: [u8; 32] = [0; 32];
|
||||
let mut pus_tc =
|
||||
PusTcCreatorWithReservedAppData::new(&mut test_buf, sph, tc_header, 0).unwrap();
|
||||
assert_eq!(pus_tc.len_written(), 13);
|
||||
assert_eq!(pus_tc.app_data_len(), 0);
|
||||
assert_eq!(pus_tc.app_data(), &[]);
|
||||
assert_eq!(pus_tc.app_data_mut(), &[]);
|
||||
let size = pus_tc.finalize();
|
||||
assert_eq!(size, 13);
|
||||
let tc_from_raw =
|
||||
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
|
||||
assert_eq!(tc_from_raw.total_len(), 13);
|
||||
verify_test_tc_with_reader(&tc_from_raw, false, 13);
|
||||
assert!(tc_from_raw.user_data().is_empty());
|
||||
verify_test_tc_raw(&test_buf);
|
||||
verify_crc_no_app_data(&test_buf);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization_no_table() {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let mut test_buf: [u8; 32] = [0; 32];
|
||||
let size = pus_tc
|
||||
.write_to_bytes(test_buf.as_mut_slice())
|
||||
.expect("Error writing TC to buffer");
|
||||
assert_eq!(size, 13);
|
||||
let tc_from_raw = PusTcReader::new_crc_no_table(&test_buf)
|
||||
.expect("Creating PUS TC struct from raw buffer failed");
|
||||
assert_eq!(tc_from_raw.total_len(), 13);
|
||||
verify_test_tc_with_reader(&tc_from_raw, false, 13);
|
||||
assert!(tc_from_raw.user_data().is_empty());
|
||||
verify_test_tc_raw(&test_buf);
|
||||
@ -953,9 +677,9 @@ mod tests {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let tc_vec = pus_tc.to_vec().expect("Error writing TC to buffer");
|
||||
assert_eq!(tc_vec.len(), 13);
|
||||
let tc_from_raw = PusTcReader::new(tc_vec.as_slice())
|
||||
let (tc_from_raw, size) = PusTcReader::new(tc_vec.as_slice())
|
||||
.expect("Creating PUS TC struct from raw buffer failed");
|
||||
assert_eq!(tc_from_raw.total_len(), 13);
|
||||
assert_eq!(size, 13);
|
||||
verify_test_tc_with_reader(&tc_from_raw, false, 13);
|
||||
assert!(tc_from_raw.user_data().is_empty());
|
||||
verify_test_tc_raw(&tc_vec);
|
||||
@ -970,7 +694,6 @@ mod tests {
|
||||
tc.update_ccsds_data_len();
|
||||
assert_eq!(tc.data_len(), 6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization_with_app_data() {
|
||||
let pus_tc = base_ping_tc_simple_ctor_with_app_data(&[1, 2, 3]);
|
||||
@ -979,15 +702,15 @@ mod tests {
|
||||
.write_to_bytes(test_buf.as_mut_slice())
|
||||
.expect("Error writing TC to buffer");
|
||||
assert_eq!(size, 16);
|
||||
let tc_from_raw =
|
||||
let (tc_from_raw, size) =
|
||||
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
|
||||
assert_eq!(tc_from_raw.total_len(), 16);
|
||||
assert_eq!(size, 16);
|
||||
verify_test_tc_with_reader(&tc_from_raw, true, 16);
|
||||
let user_data = tc_from_raw.user_data();
|
||||
assert_eq!(tc_from_raw.user_data(), tc_from_raw.app_data());
|
||||
assert_eq!(tc_from_raw.raw_data(), &test_buf[..size]);
|
||||
assert_eq!(
|
||||
tc_from_raw.opt_crc16().unwrap(),
|
||||
tc_from_raw.crc16().unwrap(),
|
||||
u16::from_be_bytes(test_buf[size - 2..size].try_into().unwrap())
|
||||
);
|
||||
assert_eq!(user_data[0], 1);
|
||||
@ -1002,9 +725,9 @@ mod tests {
|
||||
pus_tc
|
||||
.write_to_bytes(test_buf.as_mut_slice())
|
||||
.expect("Error writing TC to buffer");
|
||||
let tc_from_raw_0 =
|
||||
let (tc_from_raw_0, _) =
|
||||
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
|
||||
let tc_from_raw_1 =
|
||||
let (tc_from_raw_1, _) =
|
||||
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
|
||||
assert_eq!(tc_from_raw_0, tc_from_raw_1);
|
||||
}
|
||||
@ -1073,17 +796,22 @@ mod tests {
|
||||
let res = pus_tc.write_to_bytes(test_buf.as_mut_slice());
|
||||
assert!(res.is_err());
|
||||
let err = res.unwrap_err();
|
||||
assert_eq!(
|
||||
err,
|
||||
ByteConversionError::ToSliceTooSmall {
|
||||
found: 12,
|
||||
expected: 13
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"target slice with size 12 is too small, expected size of at least 13"
|
||||
);
|
||||
if let PusError::ByteConversion(e) = err {
|
||||
assert_eq!(
|
||||
e,
|
||||
ByteConversionError::ToSliceTooSmall {
|
||||
found: 12,
|
||||
expected: 13
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
err.to_string(),
|
||||
"pus error: target slice with size 12 is too small, expected size of at least 13"
|
||||
);
|
||||
assert_eq!(err.source().unwrap().to_string(), e.to_string());
|
||||
} else {
|
||||
panic!("unexpected error {err}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1151,7 +879,7 @@ mod tests {
|
||||
assert_eq!(*tc.sp_header(), comp_header);
|
||||
}
|
||||
|
||||
fn verify_test_tc_generic(tc: &(impl PusPacket + GenericPusTcSecondaryHeader)) {
|
||||
fn verify_test_tc_generic(tc: &(impl CcsdsPacket + PusPacket + GenericPusTcSecondaryHeader)) {
|
||||
assert_eq!(PusPacket::service(tc), 17);
|
||||
assert_eq!(GenericPusTcSecondaryHeader::service(tc), 17);
|
||||
assert_eq!(PusPacket::subservice(tc), 1);
|
||||
@ -1215,8 +943,8 @@ mod tests {
|
||||
let pus_tc = base_ping_tc_simple_ctor();
|
||||
let mut buf = [0; 32];
|
||||
pus_tc.write_to_bytes(&mut buf).unwrap();
|
||||
assert_eq!(pus_tc, PusTcReader::new(&buf).unwrap());
|
||||
assert_eq!(PusTcReader::new(&buf).unwrap(), pus_tc);
|
||||
assert_eq!(pus_tc, PusTcReader::new(&buf).unwrap().0);
|
||||
assert_eq!(PusTcReader::new(&buf).unwrap().0, pus_tc);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
463
src/ecss/tm.rs
463
src/ecss/tm.rs
@ -35,14 +35,13 @@
|
||||
//! println!("{:?}", &test_buf[0..written_size]);
|
||||
//!
|
||||
//! // Deserialize from the raw byte representation
|
||||
//! let ping_tm_reader = PusTmReader::new(&test_buf, 7).expect("Deserialization failed");
|
||||
//! assert_eq!(written_size, ping_tm_reader.total_len());
|
||||
//! let (ping_tm_reader, read_size) = PusTmReader::new(&test_buf, 7).expect("Deserialization failed");
|
||||
//! assert_eq!(written_size, read_size);
|
||||
//! assert_eq!(ping_tm_reader.service(), 17);
|
||||
//! assert_eq!(ping_tm_reader.subservice(), 2);
|
||||
//! assert_eq!(ping_tm_reader.apid(), 0x02);
|
||||
//! assert_eq!(ping_tm_reader.timestamp(), &time_buf);
|
||||
//! ```
|
||||
use crate::crc::{CRC_CCITT_FALSE, CRC_CCITT_FALSE_NO_TABLE};
|
||||
use crate::ecss::{
|
||||
calc_pus_crc16, ccsds_impl, crc_from_raw_data, sp_header_impls, user_data_from_raw,
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error, CrcType, PusError, PusPacket, PusVersion,
|
||||
@ -50,12 +49,12 @@ use crate::ecss::{
|
||||
};
|
||||
use crate::{
|
||||
ByteConversionError, CcsdsPacket, PacketType, SequenceFlags, SpHeader, CCSDS_HEADER_LEN,
|
||||
MAX_APID, MAX_SEQ_COUNT,
|
||||
CRC_CCITT_FALSE, MAX_APID, MAX_SEQ_COUNT,
|
||||
};
|
||||
use core::mem::size_of;
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
use zerocopy::{FromBytes, IntoBytes};
|
||||
use zerocopy::AsBytes;
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
use alloc::vec::Vec;
|
||||
@ -65,8 +64,6 @@ use crate::time::{TimeWriter, TimestampError};
|
||||
|
||||
use self::zc::PusTmSecHeaderWithoutTimestamp;
|
||||
|
||||
use super::verify_crc16_ccitt_false_from_raw_to_pus_error_no_table;
|
||||
|
||||
pub trait IsPusTelemetry {}
|
||||
|
||||
/// Length without timestamp
|
||||
@ -86,9 +83,9 @@ pub trait GenericPusTmSecondaryHeader {
|
||||
pub mod zc {
|
||||
use super::GenericPusTmSecondaryHeader;
|
||||
use crate::ecss::{PusError, PusVersion};
|
||||
use zerocopy::{FromBytes, Immutable, IntoBytes, NetworkEndian, Unaligned, U16};
|
||||
use zerocopy::{AsBytes, FromBytes, FromZeroes, NetworkEndian, Unaligned, U16};
|
||||
|
||||
#[derive(FromBytes, IntoBytes, Immutable, Unaligned)]
|
||||
#[derive(FromBytes, FromZeroes, AsBytes, Unaligned)]
|
||||
#[repr(C)]
|
||||
pub struct PusTmSecHeaderWithoutTimestamp {
|
||||
pus_version_and_sc_time_ref_status: u8,
|
||||
@ -120,10 +117,20 @@ pub mod zc {
|
||||
}
|
||||
}
|
||||
|
||||
impl PusTmSecHeaderWithoutTimestamp {
|
||||
pub fn write_to_bytes(&self, slice: &mut [u8]) -> Option<()> {
|
||||
self.write_to(slice)
|
||||
}
|
||||
|
||||
pub fn from_bytes(slice: &[u8]) -> Option<Self> {
|
||||
Self::read_from(slice)
|
||||
}
|
||||
}
|
||||
|
||||
impl GenericPusTmSecondaryHeader for PusTmSecHeaderWithoutTimestamp {
|
||||
#[inline]
|
||||
fn pus_version(&self) -> PusVersion {
|
||||
PusVersion::try_from((self.pus_version_and_sc_time_ref_status >> 4) & 0b1111)
|
||||
PusVersion::try_from(self.pus_version_and_sc_time_ref_status >> 4 & 0b1111)
|
||||
.unwrap_or(PusVersion::Invalid)
|
||||
}
|
||||
|
||||
@ -280,13 +287,13 @@ impl<'time, 'src_data> PusTmCreator<'time, 'src_data> {
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `sp_header` - Space packet header information. The correct packet type and the secondary
|
||||
/// header flag are set correctly by the constructor.
|
||||
/// header flag are set correctly by the constructor.
|
||||
/// * `sec_header` - Information contained in the secondary header, including the service
|
||||
/// and subservice type
|
||||
/// and subservice type
|
||||
/// * `source_data` - Custom application data
|
||||
/// * `set_ccsds_len` - Can be used to automatically update the CCSDS space packet data length
|
||||
/// field. If this is not set to true, [Self::update_ccsds_data_len] can be called to set
|
||||
/// the correct value to this field manually
|
||||
/// field. If this is not set to true, [Self::update_ccsds_data_len] can be called to set
|
||||
/// the correct value to this field manually
|
||||
#[inline]
|
||||
pub fn new(
|
||||
mut sp_header: SpHeader,
|
||||
@ -392,45 +399,33 @@ impl<'time, 'src_data> PusTmCreator<'time, 'src_data> {
|
||||
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
pub fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, ByteConversionError> {
|
||||
let writer_unfinalized = self.common_write(slice)?;
|
||||
Ok(writer_unfinalized.finalize())
|
||||
}
|
||||
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
pub fn write_to_bytes_crc_no_table(
|
||||
&self,
|
||||
slice: &mut [u8],
|
||||
) -> Result<usize, ByteConversionError> {
|
||||
let writer_unfinalized = self.common_write(slice)?;
|
||||
Ok(writer_unfinalized.finalize_crc_no_table())
|
||||
}
|
||||
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
pub fn write_to_bytes_no_crc(&self, slice: &mut [u8]) -> Result<usize, ByteConversionError> {
|
||||
let writer_unfinalized = self.common_write(slice)?;
|
||||
Ok(writer_unfinalized.finalize_no_crc())
|
||||
}
|
||||
|
||||
fn common_write<'a>(
|
||||
&self,
|
||||
slice: &'a mut [u8],
|
||||
) -> Result<PusTmCreatorWithReservedSourceData<'a>, ByteConversionError> {
|
||||
if self.len_written() > slice.len() {
|
||||
let mut curr_idx = 0;
|
||||
let total_size = self.len_written();
|
||||
if total_size > slice.len() {
|
||||
return Err(ByteConversionError::ToSliceTooSmall {
|
||||
found: slice.len(),
|
||||
expected: self.len_written(),
|
||||
expected: total_size,
|
||||
});
|
||||
}
|
||||
let mut writer_unfinalized = PusTmCreatorWithReservedSourceData::write_to_bytes_partially(
|
||||
slice,
|
||||
self.sp_header,
|
||||
self.sec_header,
|
||||
self.source_data.len(),
|
||||
)?;
|
||||
writer_unfinalized
|
||||
.source_data_mut()
|
||||
.copy_from_slice(self.source_data);
|
||||
Ok(writer_unfinalized)
|
||||
self.sp_header
|
||||
.write_to_be_bytes(&mut slice[0..CCSDS_HEADER_LEN])?;
|
||||
curr_idx += CCSDS_HEADER_LEN;
|
||||
let sec_header_len = size_of::<zc::PusTmSecHeaderWithoutTimestamp>();
|
||||
let sec_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap();
|
||||
sec_header
|
||||
.write_to_bytes(&mut slice[curr_idx..curr_idx + sec_header_len])
|
||||
.ok_or(ByteConversionError::ZeroCopyToError)?;
|
||||
curr_idx += sec_header_len;
|
||||
slice[curr_idx..curr_idx + self.sec_header.timestamp.len()]
|
||||
.copy_from_slice(self.sec_header.timestamp);
|
||||
curr_idx += self.sec_header.timestamp.len();
|
||||
slice[curr_idx..curr_idx + self.source_data.len()].copy_from_slice(self.source_data);
|
||||
curr_idx += self.source_data.len();
|
||||
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)
|
||||
}
|
||||
|
||||
/// Append the raw PUS byte representation to a provided [alloc::vec::Vec]
|
||||
@ -461,21 +456,12 @@ impl WritablePusPacket for PusTmCreator<'_, '_> {
|
||||
+ self.source_data.len()
|
||||
}
|
||||
/// Write the raw PUS byte representation to a provided buffer.
|
||||
fn write_to_bytes_no_crc(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
Ok(Self::write_to_bytes_no_crc(self, slice)?)
|
||||
}
|
||||
|
||||
fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
Ok(Self::write_to_bytes(self, slice)?)
|
||||
}
|
||||
|
||||
fn write_to_bytes_crc_no_table(&self, slice: &mut [u8]) -> Result<usize, PusError> {
|
||||
Ok(Self::write_to_bytes_crc_no_table(self, slice)?)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for PusTmCreator<'_, '_> {
|
||||
#[inline]
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.sp_header == other.sp_header
|
||||
&& self.sec_header == other.sec_header
|
||||
@ -503,7 +489,7 @@ impl PusPacket for PusTmCreator<'_, '_> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn opt_crc16(&self) -> Option<u16> {
|
||||
fn crc16(&self) -> Option<u16> {
|
||||
Some(self.calc_own_crc16())
|
||||
}
|
||||
}
|
||||
@ -527,136 +513,6 @@ impl GenericPusTmSecondaryHeader for PusTmCreator<'_, '_> {
|
||||
|
||||
impl IsPusTelemetry for PusTmCreator<'_, '_> {}
|
||||
|
||||
/// A specialized variant of [PusTmCreator] designed for efficiency when handling large source
|
||||
/// data.
|
||||
///
|
||||
/// Unlike [PusTmCreator], this type does not require the user to provide the source data
|
||||
/// as a separate slice. Instead, it allows writing the source data directly into the provided
|
||||
/// serialization buffer. This eliminates the need for an intermediate buffer and the associated
|
||||
/// memory copy, improving performance, particularly when working with large payloads.
|
||||
///
|
||||
/// **Important:** The total length of the source data must be known and specified in advance
|
||||
/// to ensure correct serialization behavior.
|
||||
///
|
||||
/// Note that this abstraction intentionally omits certain trait implementations that are available
|
||||
/// on [PusTmCreator], as they are not applicable in this optimized usage pattern.
|
||||
pub struct PusTmCreatorWithReservedSourceData<'buf> {
|
||||
buf: &'buf mut [u8],
|
||||
source_data_offset: usize,
|
||||
full_len: usize,
|
||||
}
|
||||
|
||||
impl<'buf> PusTmCreatorWithReservedSourceData<'buf> {
|
||||
/// Generates a new instance with reserved space for the user source data.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `sp_header` - Space packet header information. The correct packet type and the secondary
|
||||
/// header flag are set correctly by the constructor.
|
||||
/// * `sec_header` - Information contained in the secondary header, including the service
|
||||
/// and subservice type
|
||||
/// * `src_data_len` - Custom source data length
|
||||
#[inline]
|
||||
pub fn new(
|
||||
buf: &'buf mut [u8],
|
||||
mut sp_header: SpHeader,
|
||||
sec_header: PusTmSecondaryHeader,
|
||||
src_data_len: usize,
|
||||
) -> Result<Self, ByteConversionError> {
|
||||
sp_header.set_packet_type(PacketType::Tm);
|
||||
sp_header.set_sec_header_flag();
|
||||
let len_written =
|
||||
PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA + sec_header.timestamp.len() + src_data_len;
|
||||
if len_written > buf.len() {
|
||||
return Err(ByteConversionError::ToSliceTooSmall {
|
||||
found: buf.len(),
|
||||
expected: len_written,
|
||||
});
|
||||
}
|
||||
sp_header.data_len = len_written as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;
|
||||
Self::write_to_bytes_partially(buf, sp_header, sec_header, src_data_len)
|
||||
}
|
||||
|
||||
fn write_to_bytes_partially(
|
||||
buf: &'buf mut [u8],
|
||||
sp_header: SpHeader,
|
||||
sec_header: PusTmSecondaryHeader,
|
||||
src_data_len: usize,
|
||||
) -> Result<Self, ByteConversionError> {
|
||||
let mut curr_idx = 0;
|
||||
sp_header.write_to_be_bytes(&mut buf[0..CCSDS_HEADER_LEN])?;
|
||||
curr_idx += CCSDS_HEADER_LEN;
|
||||
let sec_header_len = size_of::<zc::PusTmSecHeaderWithoutTimestamp>();
|
||||
let sec_header_zc = zc::PusTmSecHeaderWithoutTimestamp::try_from(sec_header).unwrap();
|
||||
sec_header_zc
|
||||
.write_to(&mut buf[curr_idx..curr_idx + sec_header_len])
|
||||
.map_err(|_| ByteConversionError::ZeroCopyToError)?;
|
||||
curr_idx += sec_header_len;
|
||||
buf[curr_idx..curr_idx + sec_header.timestamp.len()].copy_from_slice(sec_header.timestamp);
|
||||
curr_idx += sec_header.timestamp.len();
|
||||
let source_data_offset = curr_idx;
|
||||
curr_idx += src_data_len;
|
||||
Ok(Self {
|
||||
buf,
|
||||
source_data_offset,
|
||||
full_len: curr_idx + 2,
|
||||
})
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub const fn len_written(&self) -> usize {
|
||||
self.full_len
|
||||
}
|
||||
|
||||
/// Mutable access to the source data buffer.
|
||||
#[inline]
|
||||
pub fn source_data_mut(&mut self) -> &mut [u8] {
|
||||
&mut self.buf[self.source_data_offset..self.full_len - 2]
|
||||
}
|
||||
|
||||
/// Access to the source data buffer.
|
||||
#[inline]
|
||||
pub fn source_data(&self) -> &[u8] {
|
||||
&self.buf[self.source_data_offset..self.full_len - 2]
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn source_data_len(&self) -> usize {
|
||||
self.full_len - 2 - self.source_data_offset
|
||||
}
|
||||
|
||||
/// Finalize the TM packet by calculating and writing the CRC16.
|
||||
///
|
||||
/// Returns the full packet length.
|
||||
pub fn finalize(self) -> usize {
|
||||
let mut digest = CRC_CCITT_FALSE.digest();
|
||||
digest.update(&self.buf[0..self.full_len - 2]);
|
||||
self.buf[self.full_len - 2..self.full_len]
|
||||
.copy_from_slice(&digest.finalize().to_be_bytes());
|
||||
self.full_len
|
||||
}
|
||||
|
||||
/// Finalize the TM packet by calculating and writing the CRC16 using a table-less
|
||||
/// implementation.
|
||||
///
|
||||
/// Returns the full packet length.
|
||||
pub fn finalize_crc_no_table(self) -> usize {
|
||||
let mut digest = CRC_CCITT_FALSE_NO_TABLE.digest();
|
||||
digest.update(&self.buf[0..self.full_len - 2]);
|
||||
self.buf[self.full_len - 2..self.full_len]
|
||||
.copy_from_slice(&digest.finalize().to_be_bytes());
|
||||
self.full_len
|
||||
}
|
||||
|
||||
/// Finalize the TM packet without writing the CRC16.
|
||||
///
|
||||
/// Returns the length WITHOUT the CRC16.
|
||||
#[inline]
|
||||
pub fn finalize_no_crc(self) -> usize {
|
||||
self.full_len - 2
|
||||
}
|
||||
}
|
||||
|
||||
/// This class models the PUS C telemetry packet. It is the primary data structure to read
|
||||
/// a telemetry packet from raw bytes.
|
||||
///
|
||||
@ -688,26 +544,7 @@ impl<'raw_data> PusTmReader<'raw_data> {
|
||||
///
|
||||
/// This function will check the CRC-16 of the PUS packet and will return an appropriate
|
||||
/// [PusError] if the check fails.
|
||||
pub fn new(slice: &'raw_data [u8], timestamp_len: usize) -> Result<Self, PusError> {
|
||||
let tc = Self::new_no_crc_check(slice, timestamp_len)?;
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error(tc.raw_data(), tc.crc16)?;
|
||||
Ok(tc)
|
||||
}
|
||||
|
||||
/// Like [PusTmReader::new] but uses a table-less CRC implementation.
|
||||
pub fn new_crc_no_table(
|
||||
slice: &'raw_data [u8],
|
||||
timestamp_len: usize,
|
||||
) -> Result<Self, PusError> {
|
||||
let tc = Self::new_no_crc_check(slice, timestamp_len)?;
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error_no_table(tc.raw_data(), tc.crc16)?;
|
||||
Ok(tc)
|
||||
}
|
||||
|
||||
pub fn new_no_crc_check(
|
||||
slice: &'raw_data [u8],
|
||||
timestamp_len: usize,
|
||||
) -> Result<Self, PusError> {
|
||||
pub fn new(slice: &'raw_data [u8], timestamp_len: usize) -> Result<(Self, usize), PusError> {
|
||||
let raw_data_len = slice.len();
|
||||
if raw_data_len < PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA {
|
||||
return Err(ByteConversionError::FromSliceTooSmall {
|
||||
@ -734,10 +571,10 @@ impl<'raw_data> PusTmReader<'raw_data> {
|
||||
}
|
||||
.into());
|
||||
}
|
||||
let sec_header_zc = zc::PusTmSecHeaderWithoutTimestamp::read_from_bytes(
|
||||
let sec_header_zc = zc::PusTmSecHeaderWithoutTimestamp::from_bytes(
|
||||
&slice[current_idx..current_idx + PUS_TM_MIN_SEC_HEADER_LEN],
|
||||
)
|
||||
.map_err(|_| ByteConversionError::ZeroCopyFromError)?;
|
||||
.ok_or(ByteConversionError::ZeroCopyFromError)?;
|
||||
current_idx += PUS_TM_MIN_SEC_HEADER_LEN;
|
||||
let zc_sec_header_wrapper = zc::PusTmSecHeader {
|
||||
zc_header: sec_header_zc,
|
||||
@ -745,13 +582,15 @@ impl<'raw_data> PusTmReader<'raw_data> {
|
||||
};
|
||||
current_idx += timestamp_len;
|
||||
let raw_data = &slice[0..total_len];
|
||||
Ok(Self {
|
||||
let pus_tm = Self {
|
||||
sp_header,
|
||||
sec_header: PusTmSecondaryHeader::try_from(zc_sec_header_wrapper).unwrap(),
|
||||
raw_data: &slice[0..total_len],
|
||||
source_data: user_data_from_raw(current_idx, total_len, slice)?,
|
||||
crc16: crc_from_raw_data(raw_data)?,
|
||||
})
|
||||
};
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error(raw_data, pus_tm.crc16)?;
|
||||
Ok((pus_tm, total_len))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -769,11 +608,6 @@ impl<'raw_data> PusTmReader<'raw_data> {
|
||||
self.sec_header.timestamp
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn crc16(&self) -> u16 {
|
||||
self.crc16
|
||||
}
|
||||
|
||||
/// This function will return the slice [Self] was constructed from.
|
||||
#[inline]
|
||||
pub fn raw_data(&self) -> &[u8] {
|
||||
@ -810,8 +644,8 @@ impl PusPacket for PusTmReader<'_> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn opt_crc16(&self) -> Option<u16> {
|
||||
Some(self.crc16())
|
||||
fn crc16(&self) -> Option<u16> {
|
||||
Some(self.crc16)
|
||||
}
|
||||
}
|
||||
|
||||
@ -876,7 +710,7 @@ impl<'raw> PusTmZeroCopyWriter<'raw> {
|
||||
if raw_tm_len < CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN + timestamp_len {
|
||||
return None;
|
||||
}
|
||||
let sp_header = crate::zc::SpHeader::read_from_bytes(&raw_tm[0..CCSDS_HEADER_LEN]).unwrap();
|
||||
let sp_header = crate::zc::SpHeader::from_bytes(&raw_tm[0..CCSDS_HEADER_LEN]).unwrap();
|
||||
if raw_tm_len < sp_header.total_len() {
|
||||
return None;
|
||||
}
|
||||
@ -917,7 +751,7 @@ impl<'raw> PusTmZeroCopyWriter<'raw> {
|
||||
#[inline]
|
||||
pub fn sp_header(&self) -> crate::zc::SpHeader {
|
||||
// Valid minimum length of packet was checked before.
|
||||
crate::zc::SpHeader::read_from_bytes(&self.raw_tm[0..CCSDS_HEADER_LEN]).unwrap()
|
||||
crate::zc::SpHeader::from_bytes(&self.raw_tm[0..CCSDS_HEADER_LEN]).unwrap()
|
||||
}
|
||||
|
||||
/// Helper API to generate the portion of the secondary header without a timestamp from the
|
||||
@ -925,7 +759,7 @@ impl<'raw> PusTmZeroCopyWriter<'raw> {
|
||||
#[inline]
|
||||
pub fn sec_header_without_timestamp(&self) -> PusTmSecHeaderWithoutTimestamp {
|
||||
// Valid minimum length of packet was checked before.
|
||||
PusTmSecHeaderWithoutTimestamp::read_from_bytes(
|
||||
PusTmSecHeaderWithoutTimestamp::from_bytes(
|
||||
&self.raw_tm[CCSDS_HEADER_LEN..CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN],
|
||||
)
|
||||
.unwrap()
|
||||
@ -998,7 +832,7 @@ impl PusPacket for PusTmZeroCopyWriter<'_> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn opt_crc16(&self) -> Option<u16> {
|
||||
fn crc16(&self) -> Option<u16> {
|
||||
Some(u16::from_be_bytes(
|
||||
self.raw_tm[self.sp_header().total_len() - 2..self.sp_header().total_len()]
|
||||
.try_into()
|
||||
@ -1094,66 +928,7 @@ mod tests {
|
||||
.write_to_bytes(&mut buf)
|
||||
.expect("Serialization failed");
|
||||
assert_eq!(ser_len, 22);
|
||||
verify_raw_ping_reply(pus_tm.opt_crc16(), &buf);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_no_source_data_alt_ctor() {
|
||||
let timestamp = dummy_timestamp();
|
||||
let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();
|
||||
let tm_header = PusTmSecondaryHeader::new_simple(17, 2, timestamp);
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let mut pus_tm =
|
||||
PusTmCreatorWithReservedSourceData::new(&mut buf, sph, tm_header, 0).unwrap();
|
||||
assert_eq!(pus_tm.source_data_len(), 0);
|
||||
assert_eq!(pus_tm.source_data(), &[]);
|
||||
assert_eq!(pus_tm.source_data_mut(), &[]);
|
||||
let ser_len = pus_tm.finalize();
|
||||
assert_eq!(ser_len, 22);
|
||||
verify_raw_ping_reply(None, &buf);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_no_source_data_alt_ctor_no_crc() {
|
||||
let timestamp = dummy_timestamp();
|
||||
let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();
|
||||
let tm_header = PusTmSecondaryHeader::new_simple(17, 2, timestamp);
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let mut pus_tm =
|
||||
PusTmCreatorWithReservedSourceData::new(&mut buf, sph, tm_header, 0).unwrap();
|
||||
assert_eq!(pus_tm.source_data_len(), 0);
|
||||
assert_eq!(pus_tm.source_data(), &[]);
|
||||
assert_eq!(pus_tm.source_data_mut(), &[]);
|
||||
let ser_len = pus_tm.finalize_no_crc();
|
||||
assert_eq!(ser_len, 20);
|
||||
verify_raw_ping_reply_no_crc(&buf);
|
||||
assert_eq!(buf[20], 0);
|
||||
assert_eq!(buf[21], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_no_source_data_no_table() {
|
||||
let timestamp = dummy_timestamp();
|
||||
let pus_tm = base_ping_reply_full_ctor(timestamp);
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let ser_len = pus_tm
|
||||
.write_to_bytes_crc_no_table(&mut buf)
|
||||
.expect("Serialization failed");
|
||||
assert_eq!(ser_len, 22);
|
||||
verify_raw_ping_reply(pus_tm.opt_crc16(), &buf);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_no_source_data_no_crc() {
|
||||
let timestamp = dummy_timestamp();
|
||||
let pus_tm = base_ping_reply_full_ctor(timestamp);
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let ser_len = pus_tm
|
||||
.write_to_bytes_no_crc(&mut buf)
|
||||
.expect("Serialization failed");
|
||||
assert_eq!(ser_len, 20);
|
||||
assert_eq!(buf[20], 0);
|
||||
assert_eq!(buf[21], 0);
|
||||
verify_raw_ping_reply(pus_tm.crc16().unwrap(), &buf);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1170,46 +945,6 @@ mod tests {
|
||||
assert_eq!(buf[22], 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_with_source_data_alt_ctor() {
|
||||
let src_data = &[1, 2, 3];
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();
|
||||
let tc_header = PusTmSecondaryHeader::new_simple(3, 5, dummy_timestamp());
|
||||
let mut hk_reply_unwritten =
|
||||
PusTmCreatorWithReservedSourceData::new(&mut buf, sph, tc_header, 3).unwrap();
|
||||
assert_eq!(hk_reply_unwritten.source_data_len(), 3);
|
||||
assert_eq!(hk_reply_unwritten.source_data(), &[0, 0, 0]);
|
||||
assert_eq!(hk_reply_unwritten.source_data_mut(), &[0, 0, 0]);
|
||||
let source_data_mut = hk_reply_unwritten.source_data_mut();
|
||||
source_data_mut.copy_from_slice(src_data);
|
||||
let ser_len = hk_reply_unwritten.finalize();
|
||||
assert_eq!(ser_len, 25);
|
||||
assert_eq!(buf[20], 1);
|
||||
assert_eq!(buf[21], 2);
|
||||
assert_eq!(buf[22], 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serialization_with_source_data_alt_ctor_no_table() {
|
||||
let src_data = &[1, 2, 3];
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let sph = SpHeader::new_for_unseg_tm_checked(0x123, 0x234, 0).unwrap();
|
||||
let tc_header = PusTmSecondaryHeader::new_simple(3, 5, dummy_timestamp());
|
||||
let mut hk_reply_unwritten =
|
||||
PusTmCreatorWithReservedSourceData::new(&mut buf, sph, tc_header, 3).unwrap();
|
||||
assert_eq!(hk_reply_unwritten.source_data_len(), 3);
|
||||
assert_eq!(hk_reply_unwritten.source_data(), &[0, 0, 0]);
|
||||
assert_eq!(hk_reply_unwritten.source_data_mut(), &[0, 0, 0]);
|
||||
let source_data_mut = hk_reply_unwritten.source_data_mut();
|
||||
source_data_mut.copy_from_slice(src_data);
|
||||
let ser_len = hk_reply_unwritten.finalize_crc_no_table();
|
||||
assert_eq!(ser_len, 25);
|
||||
assert_eq!(buf[20], 1);
|
||||
assert_eq!(buf[21], 2);
|
||||
assert_eq!(buf[22], 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_setters() {
|
||||
let timestamp = dummy_timestamp();
|
||||
@ -1230,12 +965,11 @@ mod tests {
|
||||
let pus_tm = base_ping_reply_full_ctor(timestamp);
|
||||
let tm_vec = pus_tm.to_vec().expect("Serialization failed");
|
||||
assert_eq!(tm_vec.len(), 22);
|
||||
let tm_deserialized =
|
||||
let (tm_deserialized, size) =
|
||||
PusTmReader::new(tm_vec.as_slice(), 7).expect("Deserialization failed");
|
||||
assert_eq!(tm_vec.len(), tm_deserialized.total_len());
|
||||
assert_eq!(tm_vec.len(), size);
|
||||
verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization_no_source_data() {
|
||||
let timestamp = dummy_timestamp();
|
||||
@ -1245,48 +979,13 @@ mod tests {
|
||||
.write_to_bytes(&mut buf)
|
||||
.expect("Serialization failed");
|
||||
assert_eq!(ser_len, 22);
|
||||
let tm_deserialized = PusTmReader::new(&buf, 7).expect("Deserialization failed");
|
||||
assert_eq!(ser_len, tm_deserialized.total_len());
|
||||
let (tm_deserialized, size) = PusTmReader::new(&buf, 7).expect("Deserialization failed");
|
||||
assert_eq!(ser_len, size);
|
||||
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
|
||||
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
|
||||
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
|
||||
assert_eq!(tm_deserialized.crc16().unwrap(), pus_tm.crc16().unwrap());
|
||||
verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization_no_source_data_with_trait() {
|
||||
let timestamp = dummy_timestamp();
|
||||
let pus_tm = base_ping_reply_full_ctor(timestamp);
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let ser_len =
|
||||
WritablePusPacket::write_to_bytes(&pus_tm, &mut buf).expect("Serialization failed");
|
||||
assert_eq!(ser_len, 22);
|
||||
let tm_deserialized = PusTmReader::new(&buf, 7).expect("Deserialization failed");
|
||||
assert_eq!(ser_len, tm_deserialized.total_len());
|
||||
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
|
||||
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
|
||||
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
|
||||
verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization_no_table() {
|
||||
let timestamp = dummy_timestamp();
|
||||
let pus_tm = base_ping_reply_full_ctor(timestamp);
|
||||
let mut buf: [u8; 32] = [0; 32];
|
||||
let ser_len = pus_tm
|
||||
.write_to_bytes(&mut buf)
|
||||
.expect("Serialization failed");
|
||||
assert_eq!(ser_len, 22);
|
||||
let tm_deserialized =
|
||||
PusTmReader::new_crc_no_table(&buf, 7).expect("Deserialization failed");
|
||||
assert_eq!(ser_len, tm_deserialized.total_len());
|
||||
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
|
||||
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
|
||||
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
|
||||
verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_deserialization_faulty_crc() {
|
||||
let timestamp = dummy_timestamp();
|
||||
@ -1353,7 +1052,7 @@ mod tests {
|
||||
let res = pus_tm.append_to_vec(&mut vec);
|
||||
assert!(res.is_ok());
|
||||
assert_eq!(res.unwrap(), 22);
|
||||
verify_raw_ping_reply(pus_tm.opt_crc16(), vec.as_slice());
|
||||
verify_raw_ping_reply(pus_tm.crc16().unwrap(), vec.as_slice());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1369,7 +1068,7 @@ mod tests {
|
||||
assert_eq!(vec.len(), 26);
|
||||
}
|
||||
|
||||
fn verify_raw_ping_reply_no_crc(buf: &[u8]) {
|
||||
fn verify_raw_ping_reply(crc16: u16, buf: &[u8]) {
|
||||
// Secondary header is set -> 0b0000_1001 , APID occupies last bit of first byte
|
||||
assert_eq!(buf[0], 0x09);
|
||||
// Rest of APID 0x123
|
||||
@ -1390,19 +1089,12 @@ mod tests {
|
||||
assert_eq!(buf[12], 0x00);
|
||||
// Timestamp
|
||||
assert_eq!(&buf[13..20], dummy_timestamp());
|
||||
}
|
||||
|
||||
fn verify_raw_ping_reply(crc16: Option<u16>, buf: &[u8]) {
|
||||
verify_raw_ping_reply_no_crc(buf);
|
||||
let mut digest = CRC_CCITT_FALSE.digest();
|
||||
digest.update(&buf[0..20]);
|
||||
let crc16_calced = digest.finalize();
|
||||
let crc16_read = u16::from_be_bytes([buf[20], buf[21]]);
|
||||
assert_eq!(crc16_read, crc16_calced);
|
||||
if let Some(crc16) = crc16 {
|
||||
assert_eq!(((crc16 >> 8) & 0xff) as u8, buf[20]);
|
||||
assert_eq!((crc16 & 0xff) as u8, buf[21]);
|
||||
}
|
||||
assert_eq!(((crc16 >> 8) & 0xff) as u8, buf[20]);
|
||||
assert_eq!((crc16 & 0xff) as u8, buf[21]);
|
||||
assert_eq!(crc16, crc16_calced);
|
||||
}
|
||||
|
||||
fn verify_ping_reply(
|
||||
@ -1429,7 +1121,7 @@ mod tests {
|
||||
}
|
||||
|
||||
fn verify_ping_reply_generic(
|
||||
tm: &(impl GenericPusTmSecondaryHeader + PusPacket),
|
||||
tm: &(impl CcsdsPacket + GenericPusTmSecondaryHeader + PusPacket),
|
||||
has_user_data: bool,
|
||||
exp_full_len: usize,
|
||||
) {
|
||||
@ -1470,7 +1162,7 @@ mod tests {
|
||||
let pus_tm = base_ping_reply_full_ctor(timestamp);
|
||||
let mut buf = [0; 32];
|
||||
pus_tm.write_to_bytes(&mut buf).unwrap();
|
||||
assert_eq!(pus_tm, PusTmReader::new(&buf, timestamp.len()).unwrap());
|
||||
assert_eq!(pus_tm, PusTmReader::new(&buf, timestamp.len()).unwrap().0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1490,8 +1182,9 @@ mod tests {
|
||||
assert!(!writer.set_apid(MAX_SEQ_COUNT + 1));
|
||||
writer.finish();
|
||||
// This performs all necessary checks, including the CRC check.
|
||||
let tm_read_back = PusTmReader::new(&buf, 7).expect("Re-creating PUS TM failed");
|
||||
assert_eq!(tm_read_back.total_len(), tm_size);
|
||||
let (tm_read_back, tm_size_read_back) =
|
||||
PusTmReader::new(&buf, 7).expect("Re-creating PUS TM failed");
|
||||
assert_eq!(tm_size_read_back, tm_size);
|
||||
assert_eq!(tm_read_back.msg_counter(), 100);
|
||||
assert_eq!(tm_read_back.dest_id(), 55);
|
||||
assert_eq!(tm_read_back.seq_count(), MAX_SEQ_COUNT);
|
||||
@ -1539,7 +1232,7 @@ mod tests {
|
||||
assert_eq!(writer.sec_header_without_timestamp().msg_counter(), 100);
|
||||
assert_eq!(writer.user_data(), DUMMY_DATA);
|
||||
// Need to check crc16 before finish, because finish will update the CRC.
|
||||
let crc16 = writer.opt_crc16();
|
||||
let crc16 = writer.crc16();
|
||||
assert!(crc16.is_some());
|
||||
assert_eq!(crc16.unwrap(), crc16_raw);
|
||||
writer.finish();
|
||||
@ -1557,8 +1250,8 @@ mod tests {
|
||||
let pus_tm = base_ping_reply_full_ctor(timestamp);
|
||||
let mut buf = [0; 32];
|
||||
pus_tm.write_to_bytes(&mut buf).unwrap();
|
||||
let tm_0 = PusTmReader::new(&buf, timestamp.len()).unwrap();
|
||||
let tm_1 = PusTmReader::new(&buf, timestamp.len()).unwrap();
|
||||
let (tm_0, _) = PusTmReader::new(&buf, timestamp.len()).unwrap();
|
||||
let (tm_1, _) = PusTmReader::new(&buf, timestamp.len()).unwrap();
|
||||
assert_eq!(tm_0, tm_1);
|
||||
}
|
||||
#[test]
|
||||
@ -1630,7 +1323,7 @@ mod tests {
|
||||
PusTmCreator::new_simple(sph, 17, 2, &time_provider, &mut stamp_buf, &[], true)
|
||||
.unwrap();
|
||||
let pus_tm_vec = pus_tm.to_vec().unwrap();
|
||||
let tm_reader = PusTmReader::new(&pus_tm_vec, time_provider.len_as_bytes()).unwrap();
|
||||
let (tm_reader, _) = PusTmReader::new(&pus_tm_vec, time_provider.len_as_bytes()).unwrap();
|
||||
let output = to_allocvec(&tm_reader).unwrap();
|
||||
let output_converted_back: PusTmReader = from_bytes(&output).unwrap();
|
||||
assert_eq!(output_converted_back, tm_reader);
|
||||
|
||||
104
src/lib.rs
104
src/lib.rs
@ -26,8 +26,8 @@
|
||||
//!
|
||||
//! - [`std`](https://doc.rust-lang.org/std/): Enables functionality relying on the standard library.
|
||||
//! - [`alloc`](https://doc.rust-lang.org/alloc/): Enables features which operate on containers
|
||||
//! like [`alloc::vec::Vec`](https://doc.rust-lang.org/beta/alloc/vec/struct.Vec.html).
|
||||
//! Enabled by the `std` feature.
|
||||
//! like [`alloc::vec::Vec`](https://doc.rust-lang.org/beta/alloc/vec/struct.Vec.html).
|
||||
//! Enabled by the `std` feature.
|
||||
//!
|
||||
//! ### Optional features
|
||||
//!
|
||||
@ -55,25 +55,28 @@
|
||||
//! println!("{:x?}", &ccsds_buf[0..6]);
|
||||
//! ```
|
||||
#![no_std]
|
||||
#![cfg_attr(docsrs, feature(doc_auto_cfg))]
|
||||
#![cfg_attr(docs_rs, feature(doc_auto_cfg))]
|
||||
#[cfg(feature = "alloc")]
|
||||
extern crate alloc;
|
||||
#[cfg(any(feature = "std", test))]
|
||||
extern crate std;
|
||||
|
||||
use core::{fmt::Debug, hash::Hash};
|
||||
use core::{
|
||||
fmt::{Debug, Display, Formatter},
|
||||
hash::Hash,
|
||||
};
|
||||
use crc::{Crc, CRC_16_IBM_3740};
|
||||
use delegate::delegate;
|
||||
use zerocopy::{FromBytes, IntoBytes};
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::error::Error;
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
pub mod cfdp;
|
||||
pub mod crc;
|
||||
pub mod ecss;
|
||||
pub mod seq_count;
|
||||
pub mod time;
|
||||
pub mod uslp;
|
||||
pub mod util;
|
||||
|
||||
mod private {
|
||||
@ -82,28 +85,62 @@ mod private {
|
||||
|
||||
pub const CCSDS_HEADER_LEN: usize = core::mem::size_of::<crate::zc::SpHeader>();
|
||||
|
||||
/// CRC algorithm used by the PUS standard, the CCSDS TC standard and the CFDP standard.
|
||||
pub const CRC_CCITT_FALSE: Crc<u16> = Crc::<u16>::new(&CRC_16_IBM_3740);
|
||||
|
||||
pub const MAX_APID: u16 = 2u16.pow(11) - 1;
|
||||
pub const MAX_SEQ_COUNT: u16 = 2u16.pow(14) - 1;
|
||||
|
||||
/// Generic error type when converting to and from raw byte slices.
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq, thiserror::Error)]
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
||||
pub enum ByteConversionError {
|
||||
/// The passed slice is too small. Returns the passed slice length and expected minimum size
|
||||
#[error("target slice with size {found} is too small, expected size of at least {expected}")]
|
||||
ToSliceTooSmall { found: usize, expected: usize },
|
||||
ToSliceTooSmall {
|
||||
found: usize,
|
||||
expected: usize,
|
||||
},
|
||||
/// The provider buffer is too small. Returns the passed slice length and expected minimum size
|
||||
#[error("source slice with size {found} too small, expected at least {expected} bytes")]
|
||||
FromSliceTooSmall { found: usize, expected: usize },
|
||||
FromSliceTooSmall {
|
||||
found: usize,
|
||||
expected: usize,
|
||||
},
|
||||
/// The [zerocopy] library failed to write to bytes
|
||||
#[error("zerocopy serialization error")]
|
||||
ZeroCopyToError,
|
||||
/// The [zerocopy] library failed to read from bytes
|
||||
#[error("zerocopy deserialization error")]
|
||||
ZeroCopyFromError,
|
||||
}
|
||||
|
||||
impl Display for ByteConversionError {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
|
||||
match self {
|
||||
ByteConversionError::ToSliceTooSmall { found, expected } => {
|
||||
write!(
|
||||
f,
|
||||
"target slice with size {} is too small, expected size of at least {}",
|
||||
found, expected
|
||||
)
|
||||
}
|
||||
ByteConversionError::FromSliceTooSmall { found, expected } => {
|
||||
write!(
|
||||
f,
|
||||
"source slice with size {} too small, expected at least {} bytes",
|
||||
found, expected
|
||||
)
|
||||
}
|
||||
ByteConversionError::ZeroCopyToError => {
|
||||
write!(f, "zerocopy serialization error")
|
||||
}
|
||||
ByteConversionError::ZeroCopyFromError => {
|
||||
write!(f, "zerocopy deserialization error")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl Error for ByteConversionError {}
|
||||
|
||||
/// CCSDS packet type enumeration.
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
@ -450,9 +487,9 @@ pub trait CcsdsPrimaryHeader {
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `version` - CCSDS version field, occupies the first 3 bits of the raw header. Will generally
|
||||
/// be set to 0b000 in all constructors provided by this crate.
|
||||
/// be set to 0b000 in all constructors provided by this crate.
|
||||
/// * `packet_id` - Packet Identifier, which can also be used as a start marker. Occupies the last
|
||||
/// 13 bits of the first two bytes of the raw header
|
||||
/// 13 bits of the first two bytes of the raw header
|
||||
/// * `psc` - Packet Sequence Control, occupies the third and fourth byte of the raw header
|
||||
/// * `data_len` - Data length field occupies the fifth and the sixth byte of the raw header
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
@ -695,8 +732,8 @@ impl SpHeader {
|
||||
expected: CCSDS_HEADER_LEN,
|
||||
});
|
||||
}
|
||||
let zc_header = zc::SpHeader::read_from_bytes(&buf[0..CCSDS_HEADER_LEN])
|
||||
.map_err(|_| ByteConversionError::ZeroCopyFromError)?;
|
||||
let zc_header = zc::SpHeader::from_bytes(&buf[0..CCSDS_HEADER_LEN])
|
||||
.ok_or(ByteConversionError::ZeroCopyFromError)?;
|
||||
Ok((Self::from(zc_header), &buf[CCSDS_HEADER_LEN..]))
|
||||
}
|
||||
|
||||
@ -714,8 +751,8 @@ impl SpHeader {
|
||||
}
|
||||
let zc_header: zc::SpHeader = zc::SpHeader::from(*self);
|
||||
zc_header
|
||||
.write_to(&mut buf[0..CCSDS_HEADER_LEN])
|
||||
.map_err(|_| ByteConversionError::ZeroCopyToError)?;
|
||||
.to_bytes(&mut buf[0..CCSDS_HEADER_LEN])
|
||||
.ok_or(ByteConversionError::ZeroCopyToError)?;
|
||||
Ok(&mut buf[CCSDS_HEADER_LEN..])
|
||||
}
|
||||
|
||||
@ -777,9 +814,9 @@ sph_from_other!(SpHeader, crate::zc::SpHeader);
|
||||
pub mod zc {
|
||||
use crate::{CcsdsPacket, CcsdsPrimaryHeader, PacketId, PacketSequenceCtrl, VERSION_MASK};
|
||||
use zerocopy::byteorder::NetworkEndian;
|
||||
use zerocopy::{FromBytes, Immutable, IntoBytes, Unaligned, U16};
|
||||
use zerocopy::{AsBytes, FromBytes, FromZeroes, Unaligned, U16};
|
||||
|
||||
#[derive(FromBytes, IntoBytes, Immutable, Unaligned, Debug)]
|
||||
#[derive(FromBytes, FromZeroes, AsBytes, Unaligned, Debug)]
|
||||
#[repr(C)]
|
||||
pub struct SpHeader {
|
||||
version_packet_id: U16<NetworkEndian>,
|
||||
@ -804,6 +841,14 @@ pub mod zc {
|
||||
data_len: U16::from(data_len),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_bytes(slice: &[u8]) -> Option<Self> {
|
||||
SpHeader::read_from(slice)
|
||||
}
|
||||
|
||||
pub fn to_bytes(&self, slice: &mut [u8]) -> Option<()> {
|
||||
self.write_to(slice)
|
||||
}
|
||||
}
|
||||
|
||||
impl CcsdsPacket for SpHeader {
|
||||
@ -872,7 +917,6 @@ pub(crate) mod tests {
|
||||
use postcard::{from_bytes, to_allocvec};
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{de::DeserializeOwned, Serialize};
|
||||
use zerocopy::FromBytes;
|
||||
|
||||
const CONST_SP: SpHeader = SpHeader::new(
|
||||
PacketId::new_for_tc(true, 0x36),
|
||||
@ -1152,7 +1196,7 @@ pub(crate) mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_zc_sph() {
|
||||
use zerocopy::IntoBytes;
|
||||
use zerocopy::AsBytes;
|
||||
|
||||
let sp_header = SpHeader::new_for_unseg_tc_checked(0x7FF, pow(2, 14) - 1, 0)
|
||||
.expect("Error creating SP header");
|
||||
@ -1172,7 +1216,7 @@ pub(crate) mod tests {
|
||||
assert_eq!(slice[5], 0x00);
|
||||
|
||||
let mut slice = [0; 6];
|
||||
sp_header_zc.write_to(slice.as_mut_slice()).unwrap();
|
||||
sp_header_zc.write_to(slice.as_mut_slice());
|
||||
assert_eq!(slice.len(), 6);
|
||||
assert_eq!(slice[0], 0x17);
|
||||
assert_eq!(slice[1], 0xFF);
|
||||
@ -1183,7 +1227,7 @@ pub(crate) mod tests {
|
||||
|
||||
let mut test_vec = vec![0_u8; 6];
|
||||
let slice = test_vec.as_mut_slice();
|
||||
sp_header_zc.write_to(slice).unwrap();
|
||||
sp_header_zc.write_to(slice);
|
||||
let slice = test_vec.as_slice();
|
||||
assert_eq!(slice.len(), 6);
|
||||
assert_eq!(slice[0], 0x17);
|
||||
@ -1193,8 +1237,8 @@ pub(crate) mod tests {
|
||||
assert_eq!(slice[4], 0x00);
|
||||
assert_eq!(slice[5], 0x00);
|
||||
|
||||
let sp_header = zc::SpHeader::read_from_bytes(slice);
|
||||
assert!(sp_header.is_ok());
|
||||
let sp_header = zc::SpHeader::from_bytes(slice);
|
||||
assert!(sp_header.is_some());
|
||||
let sp_header = sp_header.unwrap();
|
||||
assert_eq!(sp_header.ccsds_version(), 0b000);
|
||||
assert_eq!(sp_header.packet_id_raw(), 0x17FF);
|
||||
|
||||
250
src/seq_count.rs
250
src/seq_count.rs
@ -1,250 +0,0 @@
|
||||
use crate::MAX_SEQ_COUNT;
|
||||
use core::cell::Cell;
|
||||
use paste::paste;
|
||||
#[cfg(feature = "std")]
|
||||
pub use stdmod::*;
|
||||
|
||||
/// 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 SequenceCountProvider {
|
||||
type Raw: Into<u64>;
|
||||
const MAX_BIT_WIDTH: usize;
|
||||
|
||||
fn get(&self) -> Self::Raw;
|
||||
|
||||
fn increment(&self);
|
||||
|
||||
fn get_and_increment(&self) -> Self::Raw {
|
||||
let val = self.get();
|
||||
self.increment();
|
||||
val
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct SeqCountProviderSimple<T: Copy> {
|
||||
seq_count: Cell<T>,
|
||||
max_val: T,
|
||||
}
|
||||
|
||||
macro_rules! impl_for_primitives {
|
||||
($($ty: ident,)+) => {
|
||||
$(
|
||||
paste! {
|
||||
impl SeqCountProviderSimple<$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 SeqCountProviderSimple<$ty> {
|
||||
fn default() -> Self {
|
||||
Self::[<new_ $ty>]()
|
||||
}
|
||||
}
|
||||
|
||||
impl SequenceCountProvider for SeqCountProviderSimple<$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 CcsdsSimpleSeqCountProvider {
|
||||
provider: SeqCountProviderSimple<u16>,
|
||||
}
|
||||
|
||||
impl Default for CcsdsSimpleSeqCountProvider {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
provider: SeqCountProviderSimple::new_custom_max_val_u16(MAX_SEQ_COUNT),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl SequenceCountProvider for CcsdsSimpleSeqCountProvider {
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
pub mod stdmod {
|
||||
use super::*;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
macro_rules! sync_clonable_seq_counter_impl {
|
||||
($($ty: ident,)+) => {
|
||||
$(paste! {
|
||||
/// These sequence counters can be shared between threads and can also be
|
||||
/// configured to wrap around at specified maximum values. Please note that
|
||||
/// that the API provided by this class will not panic und [Mutex] lock errors,
|
||||
/// but it will yield 0 for the getter functions.
|
||||
#[derive(Clone, Default)]
|
||||
pub struct [<SeqCountProviderSync $ty:upper>] {
|
||||
seq_count: Arc<Mutex<$ty>>,
|
||||
max_val: $ty
|
||||
}
|
||||
|
||||
impl [<SeqCountProviderSync $ty:upper>] {
|
||||
pub fn new() -> Self {
|
||||
Self::new_with_max_val($ty::MAX)
|
||||
}
|
||||
|
||||
pub fn new_with_max_val(max_val: $ty) -> Self {
|
||||
Self {
|
||||
seq_count: Arc::default(),
|
||||
max_val
|
||||
}
|
||||
}
|
||||
}
|
||||
impl SequenceCountProvider for [<SeqCountProviderSync $ty:upper>] {
|
||||
type Raw = $ty;
|
||||
const MAX_BIT_WIDTH: usize = core::mem::size_of::<Self::Raw>() * 8;
|
||||
|
||||
fn get(&self) -> $ty {
|
||||
match self.seq_count.lock() {
|
||||
Ok(counter) => *counter,
|
||||
Err(_) => 0
|
||||
}
|
||||
}
|
||||
|
||||
fn increment(&self) {
|
||||
self.get_and_increment();
|
||||
}
|
||||
|
||||
fn get_and_increment(&self) -> $ty {
|
||||
match self.seq_count.lock() {
|
||||
Ok(mut counter) => {
|
||||
let val = *counter;
|
||||
if val == self.max_val {
|
||||
*counter = 0;
|
||||
} else {
|
||||
*counter += 1;
|
||||
}
|
||||
val
|
||||
}
|
||||
Err(_) => 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
})+
|
||||
}
|
||||
}
|
||||
sync_clonable_seq_counter_impl!(u8, u16, u32, u64,);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::seq_count::{
|
||||
CcsdsSimpleSeqCountProvider, SeqCountProviderSimple, SeqCountProviderSyncU8,
|
||||
SequenceCountProvider,
|
||||
};
|
||||
use crate::MAX_SEQ_COUNT;
|
||||
|
||||
#[test]
|
||||
fn test_u8_counter() {
|
||||
let u8_counter = SeqCountProviderSimple::<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 = SeqCountProviderSimple::new_u8();
|
||||
for _ in 0..256 {
|
||||
u8_counter.increment();
|
||||
}
|
||||
assert_eq!(u8_counter.get(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ccsds_counter() {
|
||||
let ccsds_counter = CcsdsSimpleSeqCountProvider::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 = CcsdsSimpleSeqCountProvider::default();
|
||||
for _ in 0..MAX_SEQ_COUNT + 1 {
|
||||
ccsds_counter.increment();
|
||||
}
|
||||
assert_eq!(ccsds_counter.get(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_atomic_ref_counters() {
|
||||
let sync_u8_counter = SeqCountProviderSyncU8::new();
|
||||
assert_eq!(sync_u8_counter.get(), 0);
|
||||
assert_eq!(sync_u8_counter.get_and_increment(), 0);
|
||||
assert_eq!(sync_u8_counter.get_and_increment(), 1);
|
||||
assert_eq!(sync_u8_counter.get(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_atomic_ref_counters_overflow() {
|
||||
let sync_u8_counter = SeqCountProviderSyncU8::new();
|
||||
for _ in 0..u8::MAX as u16 + 1 {
|
||||
sync_u8_counter.increment();
|
||||
}
|
||||
assert_eq!(sync_u8_counter.get(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_atomic_ref_counters_overflow_custom_max_val() {
|
||||
let sync_u8_counter = SeqCountProviderSyncU8::new_with_max_val(128);
|
||||
for _ in 0..129 {
|
||||
sync_u8_counter.increment();
|
||||
}
|
||||
assert_eq!(sync_u8_counter.get(), 0);
|
||||
}
|
||||
}
|
||||
@ -7,13 +7,17 @@
|
||||
use crate::private::Sealed;
|
||||
use crate::ByteConversionError;
|
||||
use core::cmp::Ordering;
|
||||
use core::fmt::Debug;
|
||||
use core::fmt::{Debug, Display, Formatter};
|
||||
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")]
|
||||
@ -89,19 +93,49 @@ pub enum SubmillisPrecision {
|
||||
Reserved = 0b11,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone, thiserror::Error)]
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
#[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),
|
||||
#[error("date before CCSDS epoch: {0}")]
|
||||
DateBeforeCcsdsEpoch(#[from] DateBeforeCcsdsEpochError),
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn length_of_day_segment_from_pfield(pfield: u8) -> LengthOfDaySegment {
|
||||
@ -266,23 +300,20 @@ 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;
|
||||
@ -297,9 +328,8 @@ impl CdsCommon for ConversionFromChronoDatetime {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "chrono")]
|
||||
impl CdsConverter for ConversionFromChronoDatetime {
|
||||
delegate::delegate! {to self.unix_conversion {
|
||||
delegate! {to self.unix_conversion {
|
||||
#[inline]
|
||||
fn unix_days_seconds(&self) -> i64;
|
||||
}}
|
||||
@ -336,6 +366,7 @@ impl ConversionFromChronoDatetime {
|
||||
Self::new_generic(dt, SubmillisPrecision::Picoseconds)
|
||||
}
|
||||
|
||||
#[cfg(feature = "chrono")]
|
||||
fn new_generic(
|
||||
dt: &chrono::DateTime<chrono::Utc>,
|
||||
prec: SubmillisPrecision,
|
||||
@ -417,7 +448,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;
|
||||
@ -431,7 +462,7 @@ impl CdsCommon for ConversionFromNow {
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl CdsConverter for ConversionFromNow {
|
||||
delegate::delegate! {to self.unix_conversion { fn unix_days_seconds(&self) -> i64; }}
|
||||
delegate! {to self.unix_conversion { fn unix_days_seconds(&self) -> i64; }}
|
||||
}
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
@ -569,7 +600,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 => (),
|
||||
_ => {
|
||||
@ -582,7 +613,7 @@ impl<ProvidesDaysLen: ProvidesDaysLength> CdsTime<ProvidesDaysLen> {
|
||||
_ => {
|
||||
return Err(TimestampError::InvalidTimeCode {
|
||||
expected: CcsdsTimeCode::Cds,
|
||||
found: (pfield >> 4) & 0b111,
|
||||
found: pfield >> 4 & 0b111,
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
@ -9,6 +9,7 @@ use serde::{Deserialize, Serialize};
|
||||
use core::fmt::{Debug, Display, Formatter};
|
||||
use core::ops::{Add, AddAssign};
|
||||
use core::time::Duration;
|
||||
use core::u64;
|
||||
|
||||
use crate::ByteConversionError;
|
||||
|
||||
|
||||
@ -6,6 +6,7 @@ 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"))]
|
||||
@ -63,12 +64,20 @@ 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, thiserror::Error)]
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
#[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)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
|
||||
|
||||
685
src/uslp/mod.rs
685
src/uslp/mod.rs
@ -1,685 +0,0 @@
|
||||
/// # Support of the CCSDS Unified Space Data Link Protocol (USLP)
|
||||
use crate::{ByteConversionError, crc::CRC_CCITT_FALSE};
|
||||
|
||||
/// 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, 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 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, 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 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)]
|
||||
pub enum UslpError {
|
||||
ByteConversion(ByteConversionError),
|
||||
HeaderIsTruncated,
|
||||
InvalidProtocolId(u8),
|
||||
InvalidConstructionRule(u8),
|
||||
InvalidVersionNumber(u8),
|
||||
InvalidVcid(u8),
|
||||
InvalidMapId(u8),
|
||||
ChecksumFailure(u16),
|
||||
}
|
||||
|
||||
impl From<ByteConversionError> for UslpError {
|
||||
fn from(value: ByteConversionError) -> Self {
|
||||
Self::ByteConversion(value)
|
||||
}
|
||||
}
|
||||
|
||||
#[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(always)]
|
||||
pub fn vc_frame_count(&self) -> u64 {
|
||||
self.vc_frame_count
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
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, 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)]
|
||||
#[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, 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 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,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
pub fn len_header(&self) -> usize {
|
||||
if self.construction_rule.applicable_to_fixed_len_tfdz() {
|
||||
3
|
||||
} else {
|
||||
1
|
||||
}
|
||||
}
|
||||
|
||||
pub fn construction_rule(&self) -> ConstructionRule {
|
||||
self.construction_rule
|
||||
}
|
||||
|
||||
pub fn uslp_protocol_id(&self) -> UslpProtocolId {
|
||||
self.uslp_protocol_id
|
||||
}
|
||||
|
||||
pub 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.
|
||||
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;
|
||||
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,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn len_frame(&self) -> usize {
|
||||
self.primary_header.len_frame()
|
||||
}
|
||||
|
||||
pub fn primary_header(&self) -> &PrimaryHeader {
|
||||
&self.primary_header
|
||||
}
|
||||
|
||||
pub fn data_field_header(&self) -> &TransferFrameDataFieldHeader {
|
||||
&self.data_field_header
|
||||
}
|
||||
|
||||
pub fn data(&self) -> &'buf [u8] {
|
||||
self.data
|
||||
}
|
||||
|
||||
pub fn operational_control_field(&self) -> &Option<u32> {
|
||||
&self.operational_control_field
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::println;
|
||||
|
||||
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()), 0x2345);
|
||||
}
|
||||
#[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);
|
||||
// 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);
|
||||
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_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());
|
||||
println!("Buffer: {:x?}", buf);
|
||||
// Now parse the frame.
|
||||
let frame = TransferFrameReader::from_bytes(&buf, true).unwrap();
|
||||
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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user