From 160b1dedf9a257b3d164f41bdfbeca79ab02d41f Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 26 Aug 2025 16:16:54 +0200 Subject: [PATCH] improvement for naming --- CHANGELOG.md | 1 + src/ecss/mod.rs | 6 ++++-- src/ecss/tc.rs | 14 +++++++------- src/ecss/tc_pus_a.rs | 14 +++++++------- src/ecss/tm.rs | 24 ++++++++++++------------ src/ecss/tm_pus_a.rs | 26 +++++++++++++------------- src/lib.rs | 2 +- 7 files changed, 45 insertions(+), 42 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e74e67f..9915792 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/). to make it more flexible. - `pus_version` API now returns a `Result` instead of a `PusVersion` to allow modelling invalid version numbers properly. +- Renamed `CcsdsPacket::total_len` to `CcsdsPacket::packet_len` ## Removed diff --git a/src/ecss/mod.rs b/src/ecss/mod.rs index 8649933..749616b 100644 --- a/src/ecss/mod.rs +++ b/src/ecss/mod.rs @@ -227,7 +227,8 @@ pub fn verify_crc16_ccitt_false_from_raw_to_pus_error_no_table( .ok_or(PusError::ChecksumFailure(crc16)) } -pub(crate) fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool { +/// Verify the CRC16 of a raw packet. +pub fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool { let mut digest = CRC_CCITT_FALSE.digest(); digest.update(raw_data); if digest.finalize() == 0 { @@ -236,7 +237,8 @@ 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 { +/// Verify the CRC16 of a raw packet, using the table-less implementation. +pub fn verify_crc16_ccitt_false_from_raw_no_table(raw_data: &[u8]) -> bool { let mut digest = CRC_CCITT_FALSE_NO_TABLE.digest(); digest.update(raw_data); if digest.finalize() == 0 { diff --git a/src/ecss/tc.rs b/src/ecss/tc.rs index 5832666..a5c6fa5 100644 --- a/src/ecss/tc.rs +++ b/src/ecss/tc.rs @@ -660,7 +660,7 @@ impl<'raw_data> PusTcReader<'raw_data> { let mut current_idx = 0; let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?; current_idx += CCSDS_HEADER_LEN; - let total_len = sp_header.total_len(); + let total_len = sp_header.packet_len(); if raw_data_len < total_len { return Err(ByteConversionError::FromSliceTooSmall { found: raw_data_len, @@ -702,7 +702,7 @@ impl<'raw_data> PusTcReader<'raw_data> { #[inline] pub fn len_packed(&self) -> usize { - self.sp_header.total_len() + self.sp_header.packet_len() } #[inline] @@ -902,7 +902,7 @@ mod tests { 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); + assert_eq!(tc_from_raw.packet_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); @@ -924,7 +924,7 @@ mod tests { 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); + assert_eq!(tc_from_raw.packet_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); @@ -941,7 +941,7 @@ mod tests { 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); + assert_eq!(tc_from_raw.packet_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); @@ -955,7 +955,7 @@ mod tests { assert_eq!(tc_vec.len(), 13); let tc_from_raw = 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!(tc_from_raw.packet_len(), 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); @@ -981,7 +981,7 @@ mod tests { assert_eq!(size, 16); let tc_from_raw = PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed"); - assert_eq!(tc_from_raw.total_len(), 16); + assert_eq!(tc_from_raw.packet_len(), 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()); diff --git a/src/ecss/tc_pus_a.rs b/src/ecss/tc_pus_a.rs index 6324090..c6d0963 100644 --- a/src/ecss/tc_pus_a.rs +++ b/src/ecss/tc_pus_a.rs @@ -716,7 +716,7 @@ impl<'raw_data> PusTcReader<'raw_data> { let mut current_idx = 0; let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?; current_idx += CCSDS_HEADER_LEN; - let total_len = sp_header.total_len(); + let total_len = sp_header.packet_len(); if raw_data_len < total_len { return Err(ByteConversionError::FromSliceTooSmall { found: raw_data_len, @@ -750,7 +750,7 @@ impl<'raw_data> PusTcReader<'raw_data> { #[inline] pub fn len_packed(&self) -> usize { - self.sp_header.total_len() + self.sp_header.packet_len() } #[inline] @@ -954,7 +954,7 @@ mod tests { assert_eq!(size, 11); let tc_from_raw = PusTcReader::new(&test_buf, None, 0) .expect("Creating PUS TC struct from raw buffer failed"); - assert_eq!(tc_from_raw.total_len(), 11); + assert_eq!(tc_from_raw.packet_len(), 11); verify_test_tc_with_reader(&tc_from_raw, false, 11); assert!(tc_from_raw.user_data().is_empty()); verify_test_tc_raw(&test_buf); @@ -976,7 +976,7 @@ mod tests { assert_eq!(size, 11); let tc_from_raw = PusTcReader::new(&test_buf, None, 0) .expect("Creating PUS TC struct from raw buffer failed"); - assert_eq!(tc_from_raw.total_len(), 11); + assert_eq!(tc_from_raw.packet_len(), 11); verify_test_tc_with_reader(&tc_from_raw, false, 11); assert!(tc_from_raw.user_data().is_empty()); verify_test_tc_raw(&test_buf); @@ -993,7 +993,7 @@ mod tests { assert_eq!(size, 11); let tc_from_raw = PusTcReader::new_crc_no_table(&test_buf, None, 0) .expect("Creating PUS TC struct from raw buffer failed"); - assert_eq!(tc_from_raw.total_len(), 11); + assert_eq!(tc_from_raw.packet_len(), 11); verify_test_tc_with_reader(&tc_from_raw, false, 11); assert!(tc_from_raw.user_data().is_empty()); verify_test_tc_raw(&test_buf); @@ -1007,7 +1007,7 @@ mod tests { assert_eq!(tc_vec.len(), 11); let tc_from_raw = PusTcReader::new(tc_vec.as_slice(), None, 0) .expect("Creating PUS TC struct from raw buffer failed"); - assert_eq!(tc_from_raw.total_len(), 11); + assert_eq!(tc_from_raw.packet_len(), 11); verify_test_tc_with_reader(&tc_from_raw, false, 11); assert!(tc_from_raw.user_data().is_empty()); verify_test_tc_raw(&tc_vec); @@ -1033,7 +1033,7 @@ mod tests { assert_eq!(size, 14); let tc_from_raw = PusTcReader::new(&test_buf, None, 0) .expect("Creating PUS TC struct from raw buffer failed"); - assert_eq!(tc_from_raw.total_len(), 14); + assert_eq!(tc_from_raw.packet_len(), 14); verify_test_tc_with_reader(&tc_from_raw, true, 14); let user_data = tc_from_raw.user_data(); assert_eq!(tc_from_raw.user_data(), tc_from_raw.app_data()); diff --git a/src/ecss/tm.rs b/src/ecss/tm.rs index 335de32..a6d531d 100644 --- a/src/ecss/tm.rs +++ b/src/ecss/tm.rs @@ -36,7 +36,7 @@ //! //! // 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()); +//! assert_eq!(written_size, ping_tm_reader.packet_len()); //! assert_eq!(ping_tm_reader.service(), 17); //! assert_eq!(ping_tm_reader.subservice(), 2); //! assert_eq!(ping_tm_reader.apid(), 0x02); @@ -725,7 +725,7 @@ impl<'raw_data> PusTmReader<'raw_data> { let mut current_idx = 0; let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?; current_idx += 6; - let total_len = sp_header.total_len(); + let total_len = sp_header.packet_len(); if raw_data_len < total_len { return Err(ByteConversionError::FromSliceTooSmall { found: raw_data_len, @@ -762,7 +762,7 @@ impl<'raw_data> PusTmReader<'raw_data> { #[inline] pub fn len_packed(&self) -> usize { - self.sp_header.total_len() + self.sp_header.packet_len() } #[inline] @@ -883,11 +883,11 @@ impl<'raw> PusTmZeroCopyWriter<'raw> { return None; } let sp_header = crate::zc::SpHeader::read_from_bytes(&raw_tm[0..CCSDS_HEADER_LEN]).unwrap(); - if raw_tm_len < sp_header.total_len() { + if raw_tm_len < sp_header.packet_len() { return None; } let writer = Self { - raw_tm: &mut raw_tm[..sp_header.total_len()], + raw_tm: &mut raw_tm[..sp_header.packet_len()], timestamp_len, }; Some(writer) @@ -1000,13 +1000,13 @@ impl PusPacket for PusTmZeroCopyWriter<'_> { #[inline] fn user_data(&self) -> &[u8] { &self.raw_tm[CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN + self.timestamp_len - ..self.sp_header().total_len() - 2] + ..self.sp_header().packet_len() - 2] } #[inline] fn opt_crc16(&self) -> Option { Some(u16::from_be_bytes( - self.raw_tm[self.sp_header().total_len() - 2..self.sp_header().total_len()] + self.raw_tm[self.sp_header().packet_len() - 2..self.sp_header().packet_len()] .try_into() .unwrap(), )) @@ -1238,7 +1238,7 @@ mod tests { assert_eq!(tm_vec.len(), 22); let tm_deserialized = PusTmReader::new(tm_vec.as_slice(), 7).expect("Deserialization failed"); - assert_eq!(tm_vec.len(), tm_deserialized.total_len()); + assert_eq!(tm_vec.len(), tm_deserialized.packet_len()); verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp()); } @@ -1252,7 +1252,7 @@ mod tests { .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!(ser_len, tm_deserialized.packet_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()); @@ -1268,7 +1268,7 @@ mod tests { 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!(ser_len, tm_deserialized.packet_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()); @@ -1286,7 +1286,7 @@ mod tests { 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!(ser_len, tm_deserialized.packet_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()); @@ -1497,7 +1497,7 @@ mod tests { 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); + assert_eq!(tm_read_back.packet_len(), 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); diff --git a/src/ecss/tm_pus_a.rs b/src/ecss/tm_pus_a.rs index c7877b1..a1d6dc8 100644 --- a/src/ecss/tm_pus_a.rs +++ b/src/ecss/tm_pus_a.rs @@ -40,7 +40,7 @@ //! //! // Deserialize from the raw byte representation //! let ping_tm_reader = PusTmReader::new(&test_buf, &SecondaryHeaderParameters::new_minimal(7)).expect("deserialization failed"); -//! assert_eq!(written_size, ping_tm_reader.total_len()); +//! assert_eq!(written_size, ping_tm_reader.packet_len()); //! assert_eq!(ping_tm_reader.service(), 17); //! assert_eq!(ping_tm_reader.subservice(), 2); //! assert_eq!(ping_tm_reader.apid(), 0x02); @@ -766,7 +766,7 @@ impl<'raw_data> PusTmReader<'raw_data> { let mut current_idx = 0; let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?; current_idx += CCSDS_HEADER_LEN; - let total_len = sp_header.total_len(); + let total_len = sp_header.packet_len(); if raw_data_len < total_len { return Err(ByteConversionError::FromSliceTooSmall { found: raw_data_len, @@ -796,7 +796,7 @@ impl<'raw_data> PusTmReader<'raw_data> { #[inline] pub fn len_packed(&self) -> usize { - self.sp_header.total_len() + self.sp_header.packet_len() } #[inline] @@ -939,11 +939,11 @@ impl<'raw> PusTmZeroCopyWriter<'raw> { return None; } let sp_header = crate::zc::SpHeader::read_from_bytes(&raw_tm[0..CCSDS_HEADER_LEN]).unwrap(); - if raw_tm_len < sp_header.total_len() { + if raw_tm_len < sp_header.packet_len() { return None; } let writer = Self { - raw_tm: &mut raw_tm[..sp_header.total_len()], + raw_tm: &mut raw_tm[..sp_header.packet_len()], sec_header_params: *sec_header_params, }; Some(writer) @@ -1113,13 +1113,13 @@ impl PusPacket for PusTmZeroCopyWriter<'_> { &self.raw_tm[CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN + self.sec_header_params.timestamp_len - ..self.sp_header().total_len() - 2] + ..self.sp_header().packet_len() - 2] } #[inline] fn opt_crc16(&self) -> Option { Some(u16::from_be_bytes( - self.raw_tm[self.sp_header().total_len() - 2..self.sp_header().total_len()] + self.raw_tm[self.sp_header().packet_len() - 2..self.sp_header().packet_len()] .try_into() .unwrap(), )) @@ -1433,7 +1433,7 @@ mod tests { assert_eq!(tm_vec.len(), 18); let tm_deserialized = PusTmReader::new(tm_vec.as_slice(), &MIN_SEC_HEADER_PARAMS) .expect("Deserialization failed"); - assert_eq!(tm_vec.len(), tm_deserialized.total_len()); + assert_eq!(tm_vec.len(), tm_deserialized.packet_len()); verify_ping_reply_with_reader(&tm_deserialized, false, 18, dummy_timestamp(), None, None); } @@ -1448,7 +1448,7 @@ mod tests { assert_eq!(ser_len, 18); let tm_deserialized = PusTmReader::new(&buf, &MIN_SEC_HEADER_PARAMS).expect("Deserialization failed"); - assert_eq!(ser_len, tm_deserialized.total_len()); + assert_eq!(ser_len, tm_deserialized.packet_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()); @@ -1479,7 +1479,7 @@ mod tests { }, ) .expect("Deserialization failed"); - assert_eq!(ser_len, tm_deserialized.total_len()); + assert_eq!(ser_len, tm_deserialized.packet_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()); @@ -1551,7 +1551,7 @@ mod tests { assert_eq!(ser_len, 18); let tm_deserialized = PusTmReader::new(&buf, &MIN_SEC_HEADER_PARAMS).expect("Deserialization failed"); - assert_eq!(ser_len, tm_deserialized.total_len()); + assert_eq!(ser_len, tm_deserialized.packet_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()); @@ -1569,7 +1569,7 @@ mod tests { assert_eq!(ser_len, 18); let tm_deserialized = PusTmReader::new_crc_no_table(&buf, &MIN_SEC_HEADER_PARAMS) .expect("Deserialization failed"); - assert_eq!(ser_len, tm_deserialized.total_len()); + assert_eq!(ser_len, tm_deserialized.packet_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()); @@ -1811,7 +1811,7 @@ mod tests { // This performs all necessary checks, including the CRC check. let tm_read_back = PusTmReader::new(&buf, &MIN_SEC_HEADER_PARAMS).expect("Re-creating PUS TM failed"); - assert_eq!(tm_read_back.total_len(), tm_size); + assert_eq!(tm_read_back.packet_len(), tm_size); assert!(tm_read_back.msg_counter().is_none()); assert!(tm_read_back.dest_id().is_none()); assert_eq!(tm_read_back.seq_count(), MAX_SEQ_COUNT); diff --git a/src/lib.rs b/src/lib.rs index 1e765a8..d7d4cb2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -376,7 +376,7 @@ pub trait CcsdsPacket { fn data_len(&self) -> u16; /// Retrieve the total packet size based on the data length field #[inline] - fn total_len(&self) -> usize { + fn packet_len(&self) -> usize { usize::from(self.data_len()) + CCSDS_HEADER_LEN + 1 }