Lines
90.35 %
Functions
40.98 %
Branches
100 %
use spacepackets::{
cfdp::{
tlv::{GenericTlv, Tlv, TlvType},
SegmentationControl, TransmissionMode,
},
util::UnsignedByteField,
};
#[cfg(feature = "alloc")]
pub use alloc_mod::*;
#[derive(Debug, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct FilePathTooLarge(pub usize);
/// This trait is an abstraction for different Put Request structures which can be used
/// by Put Request consumers.
pub trait ReadablePutRequest {
fn destination_id(&self) -> UnsignedByteField;
fn source_file(&self) -> Option<&str>;
fn dest_file(&self) -> Option<&str>;
fn trans_mode(&self) -> Option<TransmissionMode>;
fn closure_requested(&self) -> Option<bool>;
fn seg_ctrl(&self) -> Option<SegmentationControl>;
fn msgs_to_user(&self) -> Option<impl Iterator<Item = Tlv>>;
fn fault_handler_overrides(&self) -> Option<impl Iterator<Item = Tlv>>;
fn flow_label(&self) -> Option<Tlv>;
fn fs_requests(&self) -> Option<impl Iterator<Item = Tlv>>;
}
pub struct PutRequest<'src_file, 'dest_file, 'msgs_to_user, 'fh_ovrds, 'flow_label, 'fs_requests> {
pub destination_id: UnsignedByteField,
source_file: Option<&'src_file str>,
dest_file: Option<&'dest_file str>,
pub trans_mode: Option<TransmissionMode>,
pub closure_requested: Option<bool>,
pub seg_ctrl: Option<SegmentationControl>,
pub msgs_to_user: Option<&'msgs_to_user [Tlv<'msgs_to_user>]>,
pub fault_handler_overrides: Option<&'fh_ovrds [Tlv<'fh_ovrds>]>,
pub flow_label: Option<Tlv<'flow_label>>,
pub fs_requests: Option<&'fs_requests [Tlv<'fs_requests>]>,
impl<'src_file, 'dest_file, 'msgs_to_user, 'fh_ovrds, 'flow_label, 'fs_requests>
PutRequest<'src_file, 'dest_file, 'msgs_to_user, 'fh_ovrds, 'flow_label, 'fs_requests>
{
#[allow(clippy::too_many_arguments)]
pub fn new(
destination_id: UnsignedByteField,
trans_mode: Option<TransmissionMode>,
closure_requested: Option<bool>,
seg_ctrl: Option<SegmentationControl>,
msgs_to_user: Option<&'msgs_to_user [Tlv<'msgs_to_user>]>,
fault_handler_overrides: Option<&'fh_ovrds [Tlv<'fh_ovrds>]>,
flow_label: Option<Tlv<'flow_label>>,
fs_requests: Option<&'fs_requests [Tlv<'fs_requests>]>,
) -> Result<Self, FilePathTooLarge> {
generic_path_checks(source_file, dest_file)?;
Ok(Self {
destination_id,
source_file,
dest_file,
trans_mode,
closure_requested,
seg_ctrl,
msgs_to_user,
fault_handler_overrides,
flow_label,
fs_requests,
})
impl ReadablePutRequest for PutRequest<'_, '_, '_, '_, '_, '_> {
fn destination_id(&self) -> UnsignedByteField {
self.destination_id
fn source_file(&self) -> Option<&str> {
self.source_file
fn dest_file(&self) -> Option<&str> {
self.dest_file
fn trans_mode(&self) -> Option<TransmissionMode> {
self.trans_mode
fn closure_requested(&self) -> Option<bool> {
self.closure_requested
fn seg_ctrl(&self) -> Option<SegmentationControl> {
self.seg_ctrl
fn msgs_to_user(&self) -> Option<impl Iterator<Item = Tlv>> {
if let Some(msgs_to_user) = self.msgs_to_user {
return Some(msgs_to_user.iter().copied());
None
fn fault_handler_overrides(&self) -> Option<impl Iterator<Item = Tlv>> {
if let Some(fh_overrides) = self.fault_handler_overrides {
return Some(fh_overrides.iter().copied());
fn flow_label(&self) -> Option<Tlv> {
self.flow_label
fn fs_requests(&self) -> Option<impl Iterator<Item = Tlv>> {
if let Some(fs_requests) = self.msgs_to_user {
return Some(fs_requests.iter().copied());
pub fn generic_path_checks(
source_file: Option<&str>,
dest_file: Option<&str>,
) -> Result<(), FilePathTooLarge> {
if let Some(src_file) = source_file {
if src_file.len() > u8::MAX as usize {
return Err(FilePathTooLarge(src_file.len()));
if let Some(dest_file) = dest_file {
if dest_file.len() > u8::MAX as usize {
return Err(FilePathTooLarge(dest_file.len()));
Ok(())
impl<'src_file, 'dest_file> PutRequest<'src_file, 'dest_file, 'static, 'static, 'static, 'static> {
pub fn new_regular_request(
dest_id: UnsignedByteField,
source_file: &'src_file str,
dest_file: &'dest_file str,
generic_path_checks(Some(source_file), Some(dest_file))?;
destination_id: dest_id,
source_file: Some(source_file),
dest_file: Some(dest_file),
seg_ctrl: None,
msgs_to_user: None,
fault_handler_overrides: None,
flow_label: None,
fs_requests: None,
pub struct TlvWithInvalidType(pub(crate) ());
impl<'msgs_to_user> PutRequest<'static, 'static, 'msgs_to_user, 'static, 'static, 'static> {
pub fn new_msgs_to_user_only(
msgs_to_user: &'msgs_to_user [Tlv<'msgs_to_user>],
) -> Result<Self, TlvWithInvalidType> {
source_file: None,
dest_file: None,
trans_mode: None,
closure_requested: None,
msgs_to_user: Some(msgs_to_user),
/// Uses [generic_tlv_list_type_check] to check the TLV type validity of all TLV fields.
pub fn check_tlv_type_validities(&self) -> bool {
generic_tlv_list_type_check(self.msgs_to_user, TlvType::MsgToUser);
if let Some(flow_label) = &self.flow_label {
if flow_label.tlv_type().is_none() {
return false;
if flow_label.tlv_type().unwrap() != TlvType::FlowLabel {
generic_tlv_list_type_check(self.fault_handler_overrides, TlvType::FaultHandler);
generic_tlv_list_type_check(self.fs_requests, TlvType::FilestoreRequest);
true
pub fn generic_tlv_list_type_check<TlvProvider: GenericTlv>(
opt_tlvs: Option<&[TlvProvider]>,
tlv_type: TlvType,
) -> bool {
if let Some(tlvs) = opt_tlvs {
for tlv in tlvs {
if tlv.tlv_type().is_none() {
if tlv.tlv_type().unwrap() != tlv_type {
pub mod alloc_mod {
use core::str::Utf8Error;
use super::*;
use alloc::string::ToString;
cfdp::tlv::{msg_to_user::MsgToUserTlv, ReadableTlv, TlvOwned, WritableTlv},
ByteConversionError,
/// Owned variant of [PutRequest] with no lifetimes which is also [Clone]able.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PutRequestOwned {
source_file: Option<alloc::string::String>,
dest_file: Option<alloc::string::String>,
pub msgs_to_user: Option<alloc::vec::Vec<TlvOwned>>,
pub fault_handler_overrides: Option<alloc::vec::Vec<TlvOwned>>,
pub flow_label: Option<TlvOwned>,
pub fs_requests: Option<alloc::vec::Vec<TlvOwned>>,
impl PutRequestOwned {
source_file: &str,
dest_file: &str,
if source_file.len() > u8::MAX as usize {
return Err(FilePathTooLarge(source_file.len()));
source_file: Some(source_file.to_string()),
dest_file: Some(dest_file.to_string()),
msgs_to_user: &[MsgToUserTlv<'_>],
msgs_to_user: Some(msgs_to_user.iter().map(|msg| msg.tlv.to_owned()).collect()),
generic_tlv_list_type_check(self.msgs_to_user.as_deref(), TlvType::MsgToUser);
generic_tlv_list_type_check(
self.fault_handler_overrides.as_deref(),
TlvType::FaultHandler,
);
generic_tlv_list_type_check(self.fs_requests.as_deref(), TlvType::FilestoreRequest);
impl From<PutRequest<'_, '_, '_, '_, '_, '_>> for PutRequestOwned {
fn from(req: PutRequest<'_, '_, '_, '_, '_, '_>) -> Self {
Self {
destination_id: req.destination_id,
source_file: req.source_file.map(|s| s.into()),
dest_file: req.dest_file.map(|s| s.into()),
trans_mode: req.trans_mode,
closure_requested: req.closure_requested,
seg_ctrl: req.seg_ctrl,
msgs_to_user: req
.msgs_to_user
.map(|msgs_to_user| msgs_to_user.iter().map(|msg| msg.to_owned()).collect()),
fault_handler_overrides: req
.map(|fh_overides| fh_overides.iter().map(|msg| msg.to_owned()).collect()),
flow_label: req
.flow_label
.map(|flow_label_tlv| flow_label_tlv.to_owned()),
fs_requests: req
.fs_requests
.map(|fs_requests| fs_requests.iter().map(|msg| msg.to_owned()).collect()),
impl ReadablePutRequest for PutRequestOwned {
self.source_file.as_deref()
self.dest_file.as_deref()
if let Some(msgs_to_user) = &self.msgs_to_user {
return Some(msgs_to_user.iter().map(|tlv_owned| tlv_owned.as_tlv()));
if let Some(fh_overrides) = &self.fault_handler_overrides {
return Some(fh_overrides.iter().map(|tlv_owned| tlv_owned.as_tlv()));
self.flow_label.as_ref().map(|tlv| tlv.as_tlv())
if let Some(requests) = &self.fs_requests {
return Some(requests.iter().map(|tlv_owned| tlv_owned.as_tlv()));
pub struct StaticPutRequestFields {
/// Static buffer to store source file path.
pub source_file_buf: [u8; u8::MAX as usize],
/// Current source path length.
pub source_file_len: usize,
/// Static buffer to store dest file path.
pub dest_file_buf: [u8; u8::MAX as usize],
/// Current destination path length.
pub dest_file_len: usize,
impl Default for StaticPutRequestFields {
fn default() -> Self {
destination_id: UnsignedByteField::new(0, 0),
source_file_buf: [0; u8::MAX as usize],
source_file_len: Default::default(),
dest_file_buf: [0; u8::MAX as usize],
dest_file_len: Default::default(),
trans_mode: Default::default(),
closure_requested: Default::default(),
seg_ctrl: Default::default(),
impl StaticPutRequestFields {
pub fn clear(&mut self) {
self.destination_id = UnsignedByteField::new(0, 0);
self.source_file_len = 0;
self.dest_file_len = 0;
self.trans_mode = None;
self.closure_requested = None;
self.seg_ctrl = None;
/// This is a put request cache structure which can be used to cache [ReadablePutRequest]s
/// without requiring run-time allocation. The user must specify the static buffer sizes used
/// to store TLVs or list of TLVs.
pub struct StaticPutRequestCacher {
pub static_fields: StaticPutRequestFields,
opts_buf: alloc::vec::Vec<u8>,
opts_len: usize, // fs_request_start_end_pos: Option<(usize, usize)>
impl StaticPutRequestCacher {
pub fn new(max_len_opts_buf: usize) -> Self {
static_fields: StaticPutRequestFields::default(),
opts_buf: alloc::vec![0; max_len_opts_buf],
opts_len: 0,
pub fn set(
&mut self,
put_request: &impl ReadablePutRequest,
) -> Result<(), ByteConversionError> {
self.static_fields.destination_id = put_request.destination_id();
if let Some(source_file) = put_request.source_file() {
return Err(ByteConversionError::ToSliceTooSmall {
found: self.static_fields.source_file_buf.len(),
expected: source_file.len(),
});
self.static_fields.source_file_buf[..source_file.len()]
.copy_from_slice(source_file.as_bytes());
self.static_fields.source_file_len = source_file.len();
if let Some(dest_file) = put_request.dest_file() {
expected: dest_file.len(),
self.static_fields.dest_file_buf[..dest_file.len()]
.copy_from_slice(dest_file.as_bytes());
self.static_fields.dest_file_len = dest_file.len();
self.static_fields.trans_mode = put_request.trans_mode();
self.static_fields.closure_requested = put_request.closure_requested();
self.static_fields.seg_ctrl = put_request.seg_ctrl();
let mut current_idx = 0;
let mut store_tlv = |tlv: &Tlv| {
if current_idx + tlv.len_full() > self.opts_buf.len() {
found: self.opts_buf.len(),
expected: current_idx + tlv.len_full(),
// We checked the buffer lengths, so this should never fail.
tlv.write_to_bytes(&mut self.opts_buf[current_idx..current_idx + tlv.len_full()])
.unwrap();
current_idx += tlv.len_full();
if let Some(fs_req) = put_request.fs_requests() {
for fs_req in fs_req {
store_tlv(&fs_req)?;
if let Some(msgs_to_user) = put_request.msgs_to_user() {
for msg_to_user in msgs_to_user {
store_tlv(&msg_to_user)?;
self.opts_len = current_idx;
pub fn has_source_file(&self) -> bool {
self.static_fields.source_file_len > 0
pub fn has_dest_file(&self) -> bool {
self.static_fields.dest_file_len > 0
pub fn source_file(&self) -> Result<&str, Utf8Error> {
core::str::from_utf8(
&self.static_fields.source_file_buf[0..self.static_fields.source_file_len],
)
pub fn dest_file(&self) -> Result<&str, Utf8Error> {
&self.static_fields.dest_file_buf[0..self.static_fields.dest_file_len],
pub fn opts_len(&self) -> usize {
self.opts_len
pub fn opts_slice(&self) -> &[u8] {
&self.opts_buf[0..self.opts_len]
/// This clears the cacher structure. This is a cheap operation because it only
/// sets [Option]al values to [None] and the length of stores TLVs to 0.
///
/// Please note that this method will not set the values in the buffer to 0.
self.static_fields.clear();
self.opts_len = 0;
#[cfg(test)]
mod tests {
use std::string::String;
cfdp::tlv::{msg_to_user::MsgToUserTlv, ReadableTlv},
util::UbfU16,
pub const DEST_ID: UbfU16 = UbfU16::new(5);
#[test]
fn test_put_request_basic() {
let src_file = "/tmp/hello.txt";
let dest_file = "/tmp/hello2.txt";
let put_request = PutRequest::new(
DEST_ID.into(),
Some(src_file),
Some(dest_file),
None,
let identical_request =
PutRequest::new_regular_request(DEST_ID.into(), src_file, dest_file, None, None)
assert_eq!(put_request, identical_request);
fn test_put_request_path_checks_source_too_long() {
let mut invalid_path = String::from("/tmp/");
invalid_path += "a".repeat(u8::MAX as usize).as_str();
let error =
PutRequest::new_regular_request(DEST_ID.into(), &invalid_path, dest_file, None, None);
assert!(error.is_err());
let error = error.unwrap_err();
assert_eq!(u8::MAX as usize + 5, error.0);
fn test_put_request_path_checks_dest_file_too_long() {
let source_file = "/tmp/hello2.txt";
PutRequest::new_regular_request(DEST_ID.into(), source_file, &invalid_path, None, None);
fn test_owned_put_request_path_checks_source_too_long() {
let error = PutRequestOwned::new_regular_request(
&invalid_path,
fn test_owned_put_request_path_checks_dest_file_too_long() {
fn test_put_request_basic_small_ctor() {
let put_request =
assert_eq!(put_request.source_file(), Some(src_file));
assert_eq!(put_request.dest_file(), Some(dest_file));
assert_eq!(put_request.destination_id(), DEST_ID.into());
assert_eq!(put_request.seg_ctrl(), None);
assert_eq!(put_request.closure_requested(), None);
assert_eq!(put_request.trans_mode(), None);
assert!(put_request.fs_requests().is_none());
assert!(put_request.msgs_to_user().is_none());
assert!(put_request.fault_handler_overrides().is_none());
assert!(put_request.flow_label().is_none());
fn test_put_request_owned_basic() {
PutRequestOwned::new_regular_request(DEST_ID.into(), src_file, dest_file, None, None)
let put_request_cloned = put_request.clone();
assert_eq!(put_request, put_request_cloned);
fn test_put_request_cacher_basic() {
let put_request_cached = StaticPutRequestCacher::new(128);
assert_eq!(put_request_cached.static_fields.source_file_len, 0);
assert_eq!(put_request_cached.static_fields.dest_file_len, 0);
assert_eq!(put_request_cached.opts_len(), 0);
assert_eq!(put_request_cached.opts_slice(), &[]);
fn test_put_request_cacher_set() {
let mut put_request_cached = StaticPutRequestCacher::new(128);
put_request_cached.set(&put_request).unwrap();
assert_eq!(
put_request_cached.static_fields.source_file_len,
src_file.len()
put_request_cached.static_fields.dest_file_len,
dest_file.len()
assert_eq!(put_request_cached.source_file().unwrap(), src_file);
assert_eq!(put_request_cached.dest_file().unwrap(), dest_file);
fn test_put_request_cacher_set_and_clear() {
put_request_cached.clear();
fn test_messages_to_user_ctor_owned() {
let msg_to_user = MsgToUserTlv::new(&[1, 2, 3]).expect("creating message to user failed");
let put_request = PutRequestOwned::new_msgs_to_user_only(DEST_ID.into(), &[msg_to_user])
.expect("creating msgs to user only put request failed");
let msg_to_user_iter = put_request.msgs_to_user();
assert!(msg_to_user_iter.is_some());
assert!(put_request.check_tlv_type_validities());
let msg_to_user_iter = msg_to_user_iter.unwrap();
for msg_to_user_tlv in msg_to_user_iter {
assert_eq!(msg_to_user_tlv.value(), msg_to_user.value());
assert_eq!(msg_to_user_tlv.tlv_type().unwrap(), TlvType::MsgToUser);
fn test_messages_to_user_ctor() {
let binding = &[msg_to_user.to_tlv()];
let put_request = PutRequest::new_msgs_to_user_only(DEST_ID.into(), binding)
fn test_put_request_to_owned() {
let put_request_owned: PutRequestOwned = put_request.into();
assert_eq!(put_request_owned.destination_id(), DEST_ID.into());
assert_eq!(put_request_owned.source_file().unwrap(), src_file);
assert_eq!(put_request_owned.dest_file().unwrap(), dest_file);
assert!(put_request_owned.msgs_to_user().is_none());
assert!(put_request_owned.trans_mode().is_none());
assert!(put_request_owned.closure_requested().is_none());