Add chunked read/write API

Author: sosthene-nitrokey

src/api.rs

@@ -43,12 +43,14 @@ generate_enums! {
     ReadDirFilesFirst: 13
     ReadDirFilesNext: 14
     ReadFile: 15
+    ReadChunk: 65
     Metadata: 26
     // ReadCounter: 7
     RandomBytes: 16
     SerializeKey: 17
     Sign: 18
     WriteFile: 19
+    WriteChunk: 66
     UnsafeInjectKey: 20
     UnsafeInjectSharedKey: 21
     UnwrapKey: 22
@@ -241,6 +243,10 @@ pub mod request {
         ReadFile:
           - location: Location
           - path: PathBuf
+        ReadChunk:
+          - location: Location
+          - pos: OpenSeekFrom
+          - path: PathBuf
 
         Metadata:
           - location: Location
@@ -282,6 +288,12 @@ pub mod request {
           - data: Message
           - user_attribute: Option<UserAttribute>
 
+        WriteChunk:
+          - location: Location
+          - pos: OpenSeekFrom
+          - path: PathBuf
+          - data: Message
+
         UnsafeInjectKey:
           - mechanism: Mechanism        // -> implies key type
           - raw_key: SerializedKey
@@ -430,6 +442,9 @@ pub mod reply {
 
         ReadFile:
           - data: Message
+        ReadChunk:
+          - data: Message
+          - len: usize
 
         Metadata:
           - metadata: Option<crate::types::Metadata>
@@ -454,6 +469,7 @@ pub mod reply {
             - signature: Signature
 
         WriteFile:
+        WriteChunk:
 
         Verify:
             - valid: bool

src/client.rs

@@ -622,6 +622,19 @@ pub trait FilesystemClient: PollClient {
         self.request(request::ReadFile { location, path })
     }
 
+    fn read_file_chunk(
+        &mut self,
+        location: Location,
+        path: PathBuf,
+        pos: OpenSeekFrom,
+    ) -> ClientResult<'_, reply::ReadChunk, Self> {
+        self.request(request::ReadChunk {
+            location,
+            path,
+            pos,
+        })
+    }
+
     /// Fetch the Metadata for a file or directory
     ///
     /// If the file doesn't exists, return None
@@ -660,6 +673,21 @@ pub trait FilesystemClient: PollClient {
             user_attribute,
         })
     }
+
+    fn write_file_chunk(
+        &mut self,
+        location: Location,
+        path: PathBuf,
+        data: Message,
+        pos: OpenSeekFrom,
+    ) -> ClientResult<'_, reply::WriteChunk, Self> {
+        self.request(request::WriteChunk {
+            location,
+            path,
+            data,
+            pos,
+        })
+    }
 }
 
 /// All the other methods that are fit to expose.

src/service.rs

@@ -444,6 +444,14 @@ impl<P: Platform> ServiceResources<P> {
                 }))
             }
 
+            Request::ReadChunk(request) => {
+                let (data,len) = filestore.read_chunk(&request.path,request.location,request.pos)?;
+                Ok(Reply::ReadChunk(reply::ReadChunk {
+                    data,
+                    len,
+                }))
+            }
+
             Request::Metadata(request) => {
                 Ok(Reply::Metadata(reply::Metadata{
                     metadata: filestore.metadata(&request.path, request.location)?
@@ -497,6 +505,10 @@ impl<P: Platform> ServiceResources<P> {
                 filestore.write(&request.path, request.location, &request.data)?;
                 Ok(Reply::WriteFile(reply::WriteFile {} ))
             }
+            Request::WriteChunk(request) => {
+                 filestore.write_chunk(&request.path, request.location, &request.data,request.pos)?;
+                Ok(Reply::WriteChunk(reply::WriteChunk {} ))
+            }
 
             Request::UnwrapKey(request) => {
                 match request.mechanism {

src/store.rs

@@ -76,6 +76,7 @@ use crate::types::*;
 #[allow(unused_imports)]
 #[cfg(feature = "semihosting")]
 use cortex_m_semihosting::hprintln;
+use littlefs2::fs::File;
 use littlefs2::path::Path;
 
 pub mod certstore;
@@ -523,6 +524,38 @@ pub fn read<const N: usize>(
     .map_err(|_| Error::FilesystemReadFailure)
 }
 
+pub fn fs_read_chunk<Storage: LfsStorage, const N: usize>(
+    fs: &Filesystem<Storage>,
+    path: &Path,
+    pos: OpenSeekFrom,
+) -> Result<(Bytes<N>, usize), Error> {
+    let mut contents = Bytes::default();
+    contents.resize_default(contents.capacity()).unwrap();
+    let file_len = File::open_and_then(fs, path, |file| {
+        file.seek(pos.into())?;
+        let read_n = file.read(&mut contents)?;
+        contents.truncate(read_n);
+        file.len()
+    })
+    .map_err(|_| Error::FilesystemReadFailure)?;
+    Ok((contents, file_len))
+}
+/// Reads contents from path in location of store.
+#[inline(never)]
+pub fn read_chunk<const N: usize>(
+    store: impl Store,
+    location: Location,
+    path: &Path,
+    pos: OpenSeekFrom,
+) -> Result<(Bytes<N>, usize), Error> {
+    debug_now!("reading chunk {},{:?}", &path, pos);
+    match location {
+        Location::Internal => fs_read_chunk(store.ifs(), path, pos),
+        Location::External => fs_read_chunk(store.efs(), path, pos),
+        Location::Volatile => fs_read_chunk(store.vfs(), path, pos),
+    }
+}
+
 /// Writes contents to path in location of store.
 #[inline(never)]
 pub fn write(
@@ -540,6 +573,39 @@ pub fn write(
     .map_err(|_| Error::FilesystemWriteFailure)
 }
 
+pub fn fs_write_chunk<Storage: LfsStorage>(
+    fs: &Filesystem<Storage>,
+    path: &Path,
+    contents: &[u8],
+    pos: OpenSeekFrom,
+) -> Result<(), Error> {
+    File::open_and_then(fs, path, |file| {
+        use littlefs2::io::Write;
+        file.seek(pos.into())?;
+        file.write_all(contents)
+    })
+    .map_err(|_| Error::FilesystemReadFailure)?;
+    Ok(())
+}
+
+/// Writes contents to path in location of store.
+#[inline(never)]
+pub fn write_chunk(
+    store: impl Store,
+    location: Location,
+    path: &Path,
+    contents: &[u8],
+    pos: OpenSeekFrom,
+) -> Result<(), Error> {
+    debug_now!("writing {}", &path);
+    match location {
+        Location::Internal => fs_write_chunk(store.ifs(), path, contents, pos),
+        Location::External => fs_write_chunk(store.efs(), path, contents, pos),
+        Location::Volatile => fs_write_chunk(store.vfs(), path, contents, pos),
+    }
+    .map_err(|_| Error::FilesystemWriteFailure)
+}
+
 /// Creates parent directory if necessary, then writes.
 #[inline(never)]
 pub fn store(

src/store/filestore.rs

@@ -2,7 +2,7 @@ use crate::{
     error::{Error, Result},
     // service::ReadDirState,
     store::{self, Store},
-    types::{LfsStorage, Location, Message, UserAttribute},
+    types::{LfsStorage, Location, Message, OpenSeekFrom, UserAttribute},
     Bytes,
 };
 
@@ -76,7 +76,20 @@ impl<S: Store> ClientFilestore<S> {
 
 pub trait Filestore {
     fn read<const N: usize>(&mut self, path: &PathBuf, location: Location) -> Result<Bytes<N>>;
+    fn read_chunk<const N: usize>(
+        &mut self,
+        path: &PathBuf,
+        location: Location,
+        pos: OpenSeekFrom,
+    ) -> Result<(Bytes<N>, usize)>;
     fn write(&mut self, path: &PathBuf, location: Location, data: &[u8]) -> Result<()>;
+    fn write_chunk(
+        &mut self,
+        path: &PathBuf,
+        location: Location,
+        data: &[u8],
+        pos: OpenSeekFrom,
+    ) -> Result<()>;
     fn exists(&mut self, path: &PathBuf, location: Location) -> bool;
     fn metadata(&mut self, path: &PathBuf, location: Location) -> Result<Option<Metadata>>;
     fn remove_file(&mut self, path: &PathBuf, location: Location) -> Result<()>;
@@ -351,12 +364,33 @@ impl<S: Store> Filestore for ClientFilestore<S> {
 
         store::read(self.store, location, &path)
     }
+    fn read_chunk<const N: usize>(
+        &mut self,
+        path: &PathBuf,
+        location: Location,
+        pos: OpenSeekFrom,
+    ) -> Result<(Bytes<N>, usize)> {
+        let path = self.actual_path(path)?;
+
+        store::read_chunk(self.store, location, &path, pos)
+    }
 
     fn write(&mut self, path: &PathBuf, location: Location, data: &[u8]) -> Result<()> {
         let path = self.actual_path(path)?;
         store::store(self.store, location, &path, data)
     }
 
+    fn write_chunk(
+        &mut self,
+        path: &PathBuf,
+        location: Location,
+        data: &[u8],
+        pos: OpenSeekFrom,
+    ) -> Result<()> {
+        let path = self.actual_path(path)?;
+        store::write_chunk(self.store, location, &path, data, pos)
+    }
+
     fn exists(&mut self, path: &PathBuf, location: Location) -> bool {
         if let Ok(path) = self.actual_path(path) {
             store::exists(self.store, location, &path)

src/tests.rs

@@ -637,7 +637,8 @@ fn filesystem() {
     .metadata
     .is_none(),);
 
-    let data = Bytes::from_slice(&[0; 20]).unwrap();
+    let data = Bytes::from_slice(b"test data").unwrap();
+    let more_data = Bytes::from_slice(b"there's more").unwrap();
     block!(client
         .write_file(
             Location::Internal,
@@ -655,6 +656,59 @@ fn filesystem() {
     .data;
     assert_eq!(data, recv_data);
 
+    let partial_data = block!(client
+        .read_file_chunk(
+            Location::Internal,
+            PathBuf::from("test_file"),
+            OpenSeekFrom::Start(data.len() as u32)
+        )
+        .unwrap())
+    .unwrap();
+    assert_eq!(&partial_data.data, &[]);
+    assert_eq!(partial_data.len, data.len());
+
+    let partial_data = block!(client
+        .read_file_chunk(
+            Location::Internal,
+            PathBuf::from("test_file"),
+            OpenSeekFrom::Start(3)
+        )
+        .unwrap())
+    .unwrap();
+    assert_eq!(&partial_data.data, &data[3..]);
+    assert_eq!(partial_data.len, data.len());
+
+    let partial_data = block!(client
+        .read_file_chunk(
+            Location::Internal,
+            PathBuf::from("test_file"),
+            OpenSeekFrom::Start(data.len() as u32)
+        )
+        .unwrap())
+    .unwrap();
+    assert_eq!(&partial_data.data, &[]);
+    assert_eq!(partial_data.len, data.len());
+
+    block!(client
+        .write_file_chunk(
+            Location::Internal,
+            PathBuf::from("test_file"),
+            more_data.clone(),
+            OpenSeekFrom::Start(data.len() as u32)
+        )
+        .unwrap())
+    .unwrap();
+    let partial_data = block!(client
+        .read_file_chunk(
+            Location::Internal,
+            PathBuf::from("test_file"),
+            OpenSeekFrom::Start(data.len() as u32)
+        )
+        .unwrap())
+    .unwrap();
+    assert_eq!(&partial_data.data, &more_data);
+    assert_eq!(partial_data.len, data.len() + more_data.len());
+
     let metadata = block!(client
         .entry_metadata(Location::Internal, PathBuf::from("test_file"))
         .expect("no client error"))

src/types.rs

@@ -4,6 +4,7 @@ use core::ops::Deref;
 pub use generic_array::GenericArray;
 
 pub use heapless::{String, Vec};
+use littlefs2::io::SeekFrom;
 
 pub use crate::Bytes;
 
@@ -641,3 +642,21 @@ pub struct RsaCrtImportFormat<'d> {
     pub dp: &'d [u8],
     pub dq: &'d [u8],
 }
+
+/// Enumeration of possible methods to seek within an file that was just opened
+/// Used in the [`read_chunk`](crate::store::read_chunk) and [`write_chunk`](crate::store::write_chunk) calls,
+/// Where [`SeekFrom::Current`](littlefs2::io::SeekFrom::Current) would not make sense.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub enum OpenSeekFrom {
+    Start(u32),
+    End(i32),
+}
+
+impl From<OpenSeekFrom> for SeekFrom {
+    fn from(value: OpenSeekFrom) -> Self {
+        match value {
+            OpenSeekFrom::Start(o) => Self::Start(o),
+            OpenSeekFrom::End(o) => Self::End(o),
+        }
+    }
+}