continue file data PDU
All checks were successful
Rust/spacepackets/pipeline/head This commit looks good
Rust/spacepackets/pipeline/pr-main This commit looks good

This commit is contained in:
Robin Müller 2023-05-30 15:36:02 +02:00
parent 5c3c9a9bde
commit 81eb8e7887
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
4 changed files with 194 additions and 61 deletions

View File

@ -0,0 +1,19 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Check" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="check --all-features" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<option name="emulateTerminal" value="false" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="true" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<envs />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
</component>

View File

@ -1,4 +1,4 @@
use crate::cfdp::pdu::{write_file_size, PduError, PduHeader}; use crate::cfdp::pdu::{read_fss_field, write_fss_field, PduError, PduHeader};
use crate::cfdp::{CrcFlag, LargeFileFlag, PduType, SegmentMetadataFlag}; use crate::cfdp::{CrcFlag, LargeFileFlag, PduType, SegmentMetadataFlag};
use crate::{ByteConversionError, SizeMissmatch}; use crate::{ByteConversionError, SizeMissmatch};
use num_enum::{IntoPrimitive, TryFromPrimitive}; use num_enum::{IntoPrimitive, TryFromPrimitive};
@ -23,12 +23,12 @@ pub struct SegmentMetadata<'seg_meta> {
metadata: Option<&'seg_meta [u8]>, metadata: Option<&'seg_meta [u8]>,
} }
impl SegmentMetadata<'_> { impl<'seg_meta> SegmentMetadata<'seg_meta> {
pub fn written_len(&self) -> usize { pub fn written_len(&self) -> usize {
1 + self.seg_metadata_len as usize 1 + self.seg_metadata_len as usize
} }
pub fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> { pub(crate) fn write_to_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
if buf.len() < self.written_len() { if buf.len() < self.written_len() {
return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch { return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
found: buf.len(), found: buf.len(),
@ -41,6 +41,27 @@ impl SegmentMetadata<'_> {
} }
Ok(self.written_len()) Ok(self.written_len())
} }
pub(crate) fn from_bytes(buf: &'seg_meta [u8]) -> Result<Self, ByteConversionError> {
if buf.is_empty() {
return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
found: buf.len(),
expected: 2,
}));
}
let mut metadata = None;
let seg_metadata_len = (buf[0] & 0b111111) as usize;
if seg_metadata_len > 0 {
metadata = Some(&buf[1..1 + seg_metadata_len]);
}
Ok(Self {
// Can't fail, only 2 bits
record_continuation_state: RecordContinuationState::try_from((buf[0] >> 6) & 0b11)
.unwrap(),
seg_metadata_len: seg_metadata_len as u8,
metadata,
})
}
} }
#[derive(Debug, Copy, Clone, PartialEq, Eq)] #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@ -81,30 +102,33 @@ impl<'seg_meta, 'file_data> FileDataPdu<'seg_meta, 'file_data> {
if segment_metadata.is_some() { if segment_metadata.is_some() {
pdu_header.seg_metadata_flag = SegmentMetadataFlag::Present; pdu_header.seg_metadata_flag = SegmentMetadataFlag::Present;
} }
Self { let mut pdu = Self {
pdu_header, pdu_header,
segment_metadata, segment_metadata,
offset, offset,
file_data, file_data,
} };
pdu.pdu_header.pdu_datafield_len = pdu.calc_pdu_datafield_len() as u16;
pdu
} }
pub fn written_len(&self) -> usize { fn calc_pdu_datafield_len(&self) -> usize {
let mut len = self.pdu_header.header_len(); let mut len = core::mem::size_of::<u32>();
if self.segment_metadata.is_some() {
len += self.segment_metadata.as_ref().unwrap().written_len()
}
// Regular file size
len += core::mem::size_of::<u32>();
if self.pdu_header.pdu_conf.file_flag == LargeFileFlag::Large { if self.pdu_header.pdu_conf.file_flag == LargeFileFlag::Large {
len += core::mem::size_of::<u32>(); len += core::mem::size_of::<u32>();
} }
if self.segment_metadata.is_some() {
len += self.segment_metadata.as_ref().unwrap().written_len()
}
len += self.file_data.len(); len += self.file_data.len();
if self.pdu_header.pdu_conf.crc_flag == CrcFlag::WithCrc { if self.pdu_header.pdu_conf.crc_flag == CrcFlag::WithCrc {
len += 2; len += 2;
} }
len len
} }
pub fn written_len(&self) -> usize {
self.pdu_header.header_len() + self.calc_pdu_datafield_len()
}
pub fn offset(&self) -> u64 { pub fn offset(&self) -> u64 {
self.offset self.offset
@ -114,7 +138,7 @@ impl<'seg_meta, 'file_data> FileDataPdu<'seg_meta, 'file_data> {
self.file_data self.file_data
} }
pub fn seg_metadata(&self) -> Option<&SegmentMetadata> { pub fn segment_metadata(&self) -> Option<&SegmentMetadata> {
self.segment_metadata.as_ref() self.segment_metadata.as_ref()
} }
@ -134,15 +158,51 @@ impl<'seg_meta, 'file_data> FileDataPdu<'seg_meta, 'file_data> {
.unwrap() .unwrap()
.write_to_bytes(&mut buf[current_idx..])?; .write_to_bytes(&mut buf[current_idx..])?;
} }
write_file_size( current_idx += write_fss_field(
&mut current_idx,
self.pdu_header.common_pdu_conf().file_flag, self.pdu_header.common_pdu_conf().file_flag,
self.offset, self.offset,
buf, &mut buf[current_idx..],
)?; )?;
buf[current_idx..current_idx + self.file_data.len()].copy_from_slice(self.file_data); buf[current_idx..current_idx + self.file_data.len()].copy_from_slice(self.file_data);
current_idx += self.file_data.len();
Ok(current_idx) Ok(current_idx)
} }
pub fn from_bytes<'longest: 'seg_meta + 'file_data>(
buf: &'longest [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)?;
let mut min_expected_len = current_idx + core::mem::size_of::<u32>();
min_expected_len = core::cmp::max(min_expected_len, pdu_header.pdu_len());
if buf.len() < min_expected_len {
return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
found: buf.len(),
expected: min_expected_len,
})
.into());
}
let mut segment_metadata = None;
if pdu_header.seg_metadata_flag == SegmentMetadataFlag::Present {
segment_metadata = Some(SegmentMetadata::from_bytes(&buf[current_idx..])?);
current_idx += segment_metadata.as_ref().unwrap().written_len();
}
let (fss, offset) = read_fss_field(pdu_header.pdu_conf.file_flag, &buf[current_idx..]);
current_idx += fss;
if current_idx > full_len_without_crc {
return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
found: current_idx,
expected: full_len_without_crc,
})
.into());
}
Ok(Self {
pdu_header,
segment_metadata,
offset,
file_data: &buf[current_idx..full_len_without_crc],
})
}
} }
#[cfg(test)] #[cfg(test)]
@ -163,5 +223,63 @@ mod tests {
let fd_pdu = FileDataPdu::new_no_seg_metadata(pdu_header, 10, &file_data); let fd_pdu = FileDataPdu::new_no_seg_metadata(pdu_header, 10, &file_data);
assert_eq!(fd_pdu.file_data(), file_data); assert_eq!(fd_pdu.file_data(), file_data);
assert_eq!(fd_pdu.offset(), 10); assert_eq!(fd_pdu.offset(), 10);
assert!(fd_pdu.segment_metadata().is_none());
assert_eq!(
fd_pdu.written_len(),
fd_pdu.pdu_header.header_len() + core::mem::size_of::<u32>() + 4
);
}
#[test]
fn test_serialization() {
let src_id = UbfU8::new(1);
let dest_id = UbfU8::new(2);
let transaction_seq_num = UbfU8::new(3);
let common_conf =
CommonPduConfig::new_with_defaults(src_id, dest_id, transaction_seq_num).unwrap();
let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
let file_data: [u8; 4] = [1, 2, 3, 4];
let fd_pdu = FileDataPdu::new_no_seg_metadata(pdu_header, 10, &file_data);
let mut buf: [u8; 32] = [0; 32];
let res = fd_pdu.write_to_bytes(&mut buf);
assert!(res.is_ok());
let written = res.unwrap();
assert_eq!(
written,
fd_pdu.pdu_header.header_len() + core::mem::size_of::<u32>() + 4
);
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]
.try_into()
.unwrap(),
);
current_idx += 4;
assert_eq!(file_size, 10);
assert_eq!(buf[current_idx], 1);
current_idx += 1;
assert_eq!(buf[current_idx], 2);
current_idx += 1;
assert_eq!(buf[current_idx], 3);
current_idx += 1;
assert_eq!(buf[current_idx], 4);
}
#[test]
fn test_deserialization() {
let src_id = UbfU8::new(1);
let dest_id = UbfU8::new(2);
let transaction_seq_num = UbfU8::new(3);
let common_conf =
CommonPduConfig::new_with_defaults(src_id, dest_id, transaction_seq_num).unwrap();
let pdu_header = PduHeader::new_for_file_data_default(common_conf, 0);
let file_data: [u8; 4] = [1, 2, 3, 4];
let fd_pdu = FileDataPdu::new_no_seg_metadata(pdu_header, 10, &file_data);
let mut buf: [u8; 32] = [0; 32];
fd_pdu.write_to_bytes(&mut buf).unwrap();
let fd_pdu_read_back = FileDataPdu::from_bytes(&buf);
assert!(fd_pdu_read_back.is_ok());
let fd_pdu_read_back = fd_pdu_read_back.unwrap();
assert_eq!(fd_pdu_read_back, fd_pdu);
} }
} }

View File

@ -1,5 +1,5 @@
use crate::cfdp::lv::Lv; use crate::cfdp::lv::Lv;
use crate::cfdp::pdu::{write_file_size, FileDirectiveType, PduError, PduHeader}; use crate::cfdp::pdu::{read_fss_field, write_fss_field, FileDirectiveType, PduError, PduHeader};
use crate::cfdp::tlv::Tlv; use crate::cfdp::tlv::Tlv;
use crate::cfdp::{ChecksumType, CrcFlag, LargeFileFlag, PduType}; use crate::cfdp::{ChecksumType, CrcFlag, LargeFileFlag, PduType};
use crate::{ByteConversionError, SizeMissmatch, CRC_CCITT_FALSE}; use crate::{ByteConversionError, SizeMissmatch, CRC_CCITT_FALSE};
@ -131,26 +131,15 @@ impl<'src_name, 'dest_name, 'opts> MetadataPdu<'src_name, 'dest_name, 'opts> {
options: Option<&'opts [u8]>, options: Option<&'opts [u8]>,
) -> Self { ) -> Self {
pdu_header.pdu_type = PduType::FileDirective; pdu_header.pdu_type = PduType::FileDirective;
let is_large_file = pdu_header.common_pdu_conf().file_flag == LargeFileFlag::Large; let mut pdu = Self {
let has_crc = pdu_header.common_pdu_conf().crc_flag == CrcFlag::WithCrc;
pdu_header.pdu_datafield_len =
2 + 4 + src_file_name.len_full() as u16 + dest_file_name.len_full() as u16;
if is_large_file {
pdu_header.pdu_datafield_len += 4;
}
if has_crc {
pdu_header.pdu_datafield_len += 2;
}
if let Some(opts) = options {
pdu_header.pdu_datafield_len += opts.len() as u16;
}
Self {
pdu_header, pdu_header,
metadata_params, metadata_params,
src_file_name, src_file_name,
dest_file_name, dest_file_name,
options, options,
} };
pdu.pdu_header.pdu_datafield_len = pdu.calc_pdu_datafield_len() as u16;
pdu
} }
pub fn src_file_name(&self) -> Lv<'src_name> { pub fn src_file_name(&self) -> Lv<'src_name> {
@ -177,7 +166,12 @@ impl<'src_name, 'dest_name, 'opts> MetadataPdu<'src_name, 'dest_name, 'opts> {
pub fn written_len(&self) -> usize { pub fn written_len(&self) -> usize {
// One directive type octet, and one byte of the parameter field. // One directive type octet, and one byte of the parameter field.
let mut len = self.pdu_header.header_len() + 2; self.pdu_header.header_len() + self.calc_pdu_datafield_len()
}
fn calc_pdu_datafield_len(&self) -> usize {
// One directve type octet and one byte of the directive parameter field.
let mut len = 2;
if self.pdu_header.common_pdu_conf().file_flag == LargeFileFlag::Large { if self.pdu_header.common_pdu_conf().file_flag == LargeFileFlag::Large {
len += 8; len += 8;
} else { } else {
@ -214,11 +208,10 @@ impl<'src_name, 'dest_name, 'opts> MetadataPdu<'src_name, 'dest_name, 'opts> {
buf[current_idx] = ((self.metadata_params.closure_requested as u8) << 7) buf[current_idx] = ((self.metadata_params.closure_requested as u8) << 7)
| (self.metadata_params.checksum_type as u8); | (self.metadata_params.checksum_type as u8);
current_idx += 1; current_idx += 1;
write_file_size( current_idx += write_fss_field(
&mut current_idx,
self.pdu_header.common_pdu_conf().file_flag, self.pdu_header.common_pdu_conf().file_flag,
self.metadata_params.file_size, self.metadata_params.file_size,
buf, &mut buf[current_idx..],
)?; )?;
current_idx += self current_idx += self
.src_file_name .src_file_name
@ -241,7 +234,7 @@ impl<'src_name, 'dest_name, 'opts> MetadataPdu<'src_name, 'dest_name, 'opts> {
pub fn from_bytes<'longest: 'src_name + 'dest_name + 'opts>( pub fn from_bytes<'longest: 'src_name + 'dest_name + 'opts>(
buf: &'longest [u8], buf: &'longest [u8],
) -> Result<MetadataPdu<'src_name, 'dest_name, 'opts>, PduError> { ) -> Result<Self, PduError> {
let (pdu_header, mut current_idx) = PduHeader::from_bytes(buf)?; let (pdu_header, mut current_idx) = PduHeader::from_bytes(buf)?;
let full_len_without_crc = pdu_header.verify_length_and_checksum(buf)?; let full_len_without_crc = pdu_header.verify_length_and_checksum(buf)?;
let is_large_file = pdu_header.pdu_conf.file_flag == LargeFileFlag::Large; let is_large_file = pdu_header.pdu_conf.file_flag == LargeFileFlag::Large;
@ -268,22 +261,15 @@ impl<'src_name, 'dest_name, 'opts> MetadataPdu<'src_name, 'dest_name, 'opts> {
))); )));
} }
current_idx += 1; current_idx += 1;
let (fss_len, file_size) =
let file_size = if pdu_header.pdu_conf.file_flag == LargeFileFlag::Large { read_fss_field(pdu_header.pdu_conf.file_flag, &buf[current_idx + 1..]);
u64::from_be_bytes(buf[current_idx + 1..current_idx + 9].try_into().unwrap())
} else {
u32::from_be_bytes(buf[current_idx + 1..current_idx + 5].try_into().unwrap()) as u64
};
let metadata_params = MetadataGenericParams { let metadata_params = MetadataGenericParams {
closure_requested: ((buf[current_idx] >> 6) & 0b1) != 0, closure_requested: ((buf[current_idx] >> 6) & 0b1) != 0,
checksum_type: ChecksumType::try_from(buf[current_idx] & 0b1111) checksum_type: ChecksumType::try_from(buf[current_idx] & 0b1111)
.map_err(|_| PduError::InvalidChecksumType(buf[current_idx] & 0b1111))?, .map_err(|_| PduError::InvalidChecksumType(buf[current_idx] & 0b1111))?,
file_size, file_size,
}; };
current_idx += 5; current_idx += 1 + fss_len;
if is_large_file {
current_idx += 4;
}
let src_file_name = Lv::from_bytes(&buf[current_idx..])?; let src_file_name = Lv::from_bytes(&buf[current_idx..])?;
current_idx += src_file_name.len_full(); current_idx += src_file_name.len_full();
let dest_file_name = Lv::from_bytes(&buf[current_idx..])?; let dest_file_name = Lv::from_bytes(&buf[current_idx..])?;
@ -343,7 +329,7 @@ pub mod tests {
MetadataPdu<'static, 'static, 'opts>, MetadataPdu<'static, 'static, 'opts>,
) { ) {
let pdu_header = PduHeader::new_no_file_data(common_pdu_conf(crc_flag, fss), 0); let pdu_header = PduHeader::new_no_file_data(common_pdu_conf(crc_flag, fss), 0);
let metadata_params = MetadataGenericParams::new(false, ChecksumType::Crc32, 10); let metadata_params = MetadataGenericParams::new(false, ChecksumType::Crc32, 0x1010);
let src_filename = Lv::new_from_str(SRC_FILENAME).expect("Generating string LV failed"); let src_filename = Lv::new_from_str(SRC_FILENAME).expect("Generating string LV failed");
let dest_filename = let dest_filename =
Lv::new_from_str(DEST_FILENAME).expect("Generating destination LV failed"); Lv::new_from_str(DEST_FILENAME).expect("Generating destination LV failed");
@ -399,7 +385,7 @@ pub mod tests {
assert_eq!(buf[7], FileDirectiveType::MetadataPdu as u8); assert_eq!(buf[7], FileDirectiveType::MetadataPdu as u8);
assert_eq!(buf[8] >> 6, false as u8); assert_eq!(buf[8] >> 6, false as u8);
assert_eq!(buf[8] & 0b1111, ChecksumType::Crc32 as u8); assert_eq!(buf[8] & 0b1111, ChecksumType::Crc32 as u8);
assert_eq!(u32::from_be_bytes(buf[9..13].try_into().unwrap()), 10); assert_eq!(u32::from_be_bytes(buf[9..13].try_into().unwrap()), 0x1010);
let mut current_idx = 13; let mut current_idx = 13;
let src_name_from_raw = let src_name_from_raw =
Lv::from_bytes(&buf[current_idx..]).expect("Creating source name LV failed"); Lv::from_bytes(&buf[current_idx..]).expect("Creating source name LV failed");

View File

@ -468,25 +468,35 @@ impl PduHeader {
} }
} }
pub(crate) fn write_file_size( pub(crate) fn write_fss_field(
current_idx: &mut usize, file_flag: LargeFileFlag,
fss: LargeFileFlag,
file_size: u64, file_size: u64,
buf: &mut [u8], buf: &mut [u8],
) -> Result<(), PduError> { ) -> Result<usize, PduError> {
if fss == LargeFileFlag::Large { Ok(if file_flag == LargeFileFlag::Large {
buf[*current_idx..*current_idx + core::mem::size_of::<u64>()] buf[..core::mem::size_of::<u64>()].copy_from_slice(&file_size.to_be_bytes());
.copy_from_slice(&file_size.to_be_bytes()); core::mem::size_of::<u64>()
*current_idx += core::mem::size_of::<u64>()
} else { } else {
if file_size > u32::MAX as u64 { if file_size > u32::MAX as u64 {
return Err(PduError::FileSizeTooLarge(file_size)); return Err(PduError::FileSizeTooLarge(file_size));
} }
buf[*current_idx..*current_idx + core::mem::size_of::<u32>()] buf[..core::mem::size_of::<u32>()].copy_from_slice(&(file_size as u32).to_be_bytes());
.copy_from_slice(&(file_size as u32).to_be_bytes()); core::mem::size_of::<u32>()
*current_idx += core::mem::size_of::<u32>() })
}
pub(crate) fn read_fss_field(file_flag: LargeFileFlag, buf: &[u8]) -> (usize, u64) {
if file_flag == LargeFileFlag::Large {
(
core::mem::size_of::<u64>(),
u64::from_be_bytes(buf[..core::mem::size_of::<u64>()].try_into().unwrap()),
)
} else {
(
core::mem::size_of::<u32>(),
u32::from_be_bytes(buf[..core::mem::size_of::<u32>()].try_into().unwrap()).into(),
)
} }
Ok(())
} }
#[cfg(test)] #[cfg(test)]