Rid into storage trait

examples/cat.rs

@@ -2,13 +2,16 @@ use std::env;
 use std::fs::File;
 use std::io::{self, prelude::*};
 
-use fatfs::{FileSystem, FsOptions};
+use fatfs::{FsOptions, StdIoWrapper, DefaultTimeProvider, LossyOemCpConverter};
 use fscommon::BufStream;
 
+type FileSystem =
+    fatfs::FileSystem<StdIoWrapper<BufStream<File>>, DefaultTimeProvider, LossyOemCpConverter>;
+
 fn main() -> io::Result<()> {
     let file = File::open("resources/fat32.img")?;
     let buf_rdr = BufStream::new(file);
-    let fs = FileSystem::new(buf_rdr, FsOptions::new())?;
+    let fs = FileSystem::new(buf_rdr.into(), FsOptions::new())?;
     let root_dir = fs.root_dir();
     let mut file = root_dir.open_file(&env::args().nth(1).expect("filename expected"))?;
     let mut buf = vec![];

examples/ls.rs

@@ -3,7 +3,7 @@ use std::fs::File;
 use std::io;
 
 use chrono::{DateTime, Local};
-use fatfs::{FileSystem, FsOptions};
+use fatfs::{FileSystem, FsOptions, StdIoWrapper};
 use fscommon::BufStream;
 
 fn format_file_size(size: u64) -> String {
@@ -24,7 +24,7 @@ fn format_file_size(size: u64) -> String {
 fn main() -> io::Result<()> {
     let file = File::open("resources/fat32.img")?;
     let buf_rdr = BufStream::new(file);
-    let fs = FileSystem::new(buf_rdr, FsOptions::new())?;
+    let fs = FileSystem::new(StdIoWrapper::new(buf_rdr), FsOptions::new())?;
     let root_dir = fs.root_dir();
     let dir = match env::args().nth(1) {
         None => root_dir,

examples/partition.rs

@@ -1,6 +1,6 @@
 use std::{fs, io};
 
-use fatfs::{FileSystem, FsOptions};
+use fatfs::{FileSystem, FsOptions, StdIoWrapper};
 use fscommon::{BufStream, StreamSlice};
 
 fn main() -> io::Result<()> {
@@ -14,7 +14,7 @@ fn main() -> io::Result<()> {
     // Create buffered stream to optimize file access
     let buf_rdr = BufStream::new(partition);
     // Finally initialize filesystem struct using provided partition
-    let fs = FileSystem::new(buf_rdr, FsOptions::new())?;
+    let fs = FileSystem::new(StdIoWrapper::new(buf_rdr), FsOptions::new())?;
     // Read and display volume label
     println!("Volume Label: {}", fs.volume_label());
     // other operations...

examples/write.rs

@@ -1,11 +1,11 @@
 use std::fs::OpenOptions;
 use std::io::{self, prelude::*};
 
-use fatfs::{FileSystem, FsOptions};
+use fatfs::{FileSystem, FsOptions, StdIoWrapper};
 use fscommon::BufStream;
 
 fn main() -> io::Result<()> {
-    let img_file = match OpenOptions::new().read(true).write(true).open("fat.img") {
+    let img_file = match OpenOptions::new().create(true).read(true).write(true).open("fat.img") {
         Ok(file) => file,
         Err(err) => {
             println!("Failed to open image!");
@@ -14,7 +14,8 @@ fn main() -> io::Result<()> {
     };
     let buf_stream = BufStream::new(img_file);
     let options = FsOptions::new().update_accessed_date(true);
-    let fs = FileSystem::new(buf_stream, options)?;
+    let mut disk = StdIoWrapper::new(buf_stream);
+    let fs = FileSystem::new(&mut disk, options).unwrap();
     let mut file = fs.root_dir().create_file("hello.txt")?;
     file.write_all(b"Hello World!")?;
     Ok(())

src/dir.rs

@@ -789,6 +789,7 @@ impl LfnBuffer {
         };
         for (i, usc2_unit) in usc2_units.enumerate() {
             lfn.ucs2_units[i] = usc2_unit;
+            lfn.len += 1;
         }
         lfn
     }
@@ -807,7 +808,7 @@ impl LfnBuffer {
     }
 
     pub(crate) fn as_ucs2_units(&self) -> &[u16] {
-        &self.ucs2_units
+        &self.ucs2_units[..self.len]
     }
 }
 

src/fs.rs

@@ -323,24 +323,14 @@ pub struct FileSystem<IO: ReadWriteSeek, TP, OCC> {
     current_status_flags: Cell<FsStatusFlags>,
 }
 
-pub trait IntoStorage<T: Read + Write + Seek> {
-    fn into_storage(self) -> T;
-}
-
-impl<T: Read + Write + Seek> IntoStorage<T> for T {
-    fn into_storage(self) -> Self {
-        self
-    }
-}
-
-#[cfg(feature = "std")]
-impl<T: std::io::Read + std::io::Write + std::io::Seek> IntoStorage<io::StdIoWrapper<T>> for T {
-    fn into_storage(self) -> io::StdIoWrapper<Self> {
-        io::StdIoWrapper::new(self)
-    }
-}
-
-impl<IO: Read + Write + Seek, TP, OCC> FileSystem<IO, TP, OCC> {
+// #[cfg(feature = "std")]
+// impl<T: std::io::Read + std::io::Write + std::io::Seek> Into<io::StdIoWrapper<T>> for T {
+//     fn into(self) -> io::StdIoWrapper<Self> {
+//         io::StdIoWrapper::new(self)
+//     }
+// }
+
+impl<IO: ReadWriteSeek, TP, OCC> FileSystem<IO, TP, OCC> {
     /// Creates a new filesystem object instance.
     ///
     /// Supplied `storage` parameter cannot be seeked. If there is a need to read a fragment of disk
@@ -361,11 +351,10 @@ impl<IO: Read + Write + Seek, TP, OCC> FileSystem<IO, TP, OCC> {
     /// # Panics
     ///
     /// Panics in non-optimized build if `storage` position returned by `seek` is not zero.
-    pub fn new<T: IntoStorage<IO>>(storage: T, options: FsOptions<TP, OCC>) -> Result<Self, Error<IO::Error>> {
+    pub fn new(mut disk: IO, options: FsOptions<TP, OCC>) -> Result<Self, Error<IO::Error>> {
         // Make sure given image is not seeked
-        let mut disk = storage.into_storage();
         trace!("FileSystem::new");
-        debug_assert!(disk.seek(SeekFrom::Current(0))? == 0);
+        disk.seek(SeekFrom::Start(0))?;
 
         // read boot sector
         let bpb = {
@@ -1113,9 +1102,9 @@ impl FormatVolumeOptions {
 ///
 /// Panics in non-optimized build if `storage` position returned by `seek` is not zero.
 #[allow(clippy::needless_pass_by_value)]
-pub fn format_volume<S: ReadWriteSeek>(storage: &mut S, options: FormatVolumeOptions) -> Result<(), Error<S::Error>> {
+pub fn format_volume<S: ReadWriteSeek>(mut storage: S, options: FormatVolumeOptions) -> Result<(), Error<S::Error>> {
     trace!("format_volume");
-    debug_assert!(storage.seek(SeekFrom::Current(0))? == 0);
+    storage.seek(SeekFrom::Start(0))?;
 
     let bytes_per_sector = options.bytes_per_sector.unwrap_or(512);
     let total_sectors = if let Some(total_sectors) = options.total_sectors {
@@ -1136,10 +1125,10 @@ pub fn format_volume<S: ReadWriteSeek>(storage: &mut S, options: FormatVolumeOpt
     if boot.validate::<S::Error>().is_err() {
         return Err(Error::InvalidInput);
     }
-    boot.serialize(storage)?;
+    boot.serialize(&mut storage)?;
     // Make sure entire logical sector is updated (serialize method always writes 512 bytes)
     let bytes_per_sector = boot.bpb.bytes_per_sector;
-    write_zeros_until_end_of_sector(storage, bytes_per_sector)?;
+    write_zeros_until_end_of_sector(&mut storage, bytes_per_sector)?;
 
     let bpb = &boot.bpb;
     if bpb.is_fat32() {
@@ -1150,23 +1139,23 @@ pub fn format_volume<S: ReadWriteSeek>(storage: &mut S, options: FormatVolumeOpt
             dirty: false,
         };
         storage.seek(SeekFrom::Start(bpb.bytes_from_sectors(bpb.fs_info_sector())))?;
-        fs_info_sector.serialize(storage)?;
-        write_zeros_until_end_of_sector(storage, bytes_per_sector)?;
+        fs_info_sector.serialize(&mut storage)?;
+        write_zeros_until_end_of_sector(&mut storage, bytes_per_sector)?;
 
         // backup boot sector
         storage.seek(SeekFrom::Start(bpb.bytes_from_sectors(bpb.backup_boot_sector())))?;
-        boot.serialize(storage)?;
-        write_zeros_until_end_of_sector(storage, bytes_per_sector)?;
+        boot.serialize(&mut storage)?;
+        write_zeros_until_end_of_sector(&mut storage, bytes_per_sector)?;
     }
 
     // format File Allocation Table
     let reserved_sectors = bpb.reserved_sectors();
     let fat_pos = bpb.bytes_from_sectors(reserved_sectors);
     let sectors_per_all_fats = bpb.sectors_per_all_fats();
     storage.seek(SeekFrom::Start(fat_pos))?;
-    write_zeros(storage, bpb.bytes_from_sectors(sectors_per_all_fats))?;
+    write_zeros(&mut storage, bpb.bytes_from_sectors(sectors_per_all_fats))?;
     {
-        let mut fat_slice = fat_slice::<S, &mut S>(storage, bpb);
+        let mut fat_slice = fat_slice::<S, &mut S>(&mut storage, bpb);
         let sectors_per_fat = bpb.sectors_per_fat();
         let bytes_per_fat = bpb.bytes_from_sectors(sectors_per_fat);
         format_fat(&mut fat_slice, fat_type, bpb.media, bytes_per_fat, bpb.total_clusters())?;
@@ -1177,10 +1166,10 @@ pub fn format_volume<S: ReadWriteSeek>(storage: &mut S, options: FormatVolumeOpt
     let root_dir_sectors = bpb.root_dir_sectors();
     let root_dir_pos = bpb.bytes_from_sectors(root_dir_first_sector);
     storage.seek(SeekFrom::Start(root_dir_pos))?;
-    write_zeros(storage, bpb.bytes_from_sectors(root_dir_sectors))?;
+    write_zeros(&mut storage, bpb.bytes_from_sectors(root_dir_sectors))?;
     if fat_type == FatType::Fat32 {
         let root_dir_first_cluster = {
-            let mut fat_slice = fat_slice::<S, &mut S>(storage, bpb);
+            let mut fat_slice = fat_slice::<S, &mut S>(&mut storage, bpb);
             alloc_cluster(&mut fat_slice, fat_type, None, None, 1)?
         };
         assert!(root_dir_first_cluster == bpb.root_dir_first_cluster);
@@ -1189,14 +1178,14 @@ pub fn format_volume<S: ReadWriteSeek>(storage: &mut S, options: FormatVolumeOpt
         let fat32_root_dir_first_sector = first_data_sector + data_sectors_before_root_dir;
         let fat32_root_dir_pos = bpb.bytes_from_sectors(fat32_root_dir_first_sector);
         storage.seek(SeekFrom::Start(fat32_root_dir_pos))?;
-        write_zeros(storage, u64::from(bpb.cluster_size()))?;
+        write_zeros(&mut storage, u64::from(bpb.cluster_size()))?;
     }
 
     // Create volume label directory entry if volume label is specified in options
     if let Some(volume_label) = options.volume_label {
         storage.seek(SeekFrom::Start(root_dir_pos))?;
         let volume_entry = DirFileEntryData::new(volume_label, FileAttributes::VOLUME_ID);
-        volume_entry.serialize(storage)?;
+        volume_entry.serialize(&mut storage)?;
     }
 
     storage.seek(SeekFrom::Start(0))?;

src/io.rs

@@ -238,6 +238,47 @@ impl<T> From<T> for StdIoWrapper<T> {
     }
 }
 
+#[cfg(feature = "std")]
+impl<T: std::fmt::Debug> std::fmt::Debug for StdIoWrapper<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("StdIoWrapper").field("inner", &self.inner).finish()
+    }
+}
+
+
+impl<T: IoBase> IoBase for &mut T {
+    type Error = T::Error;
+}
+
+impl<T: Read> Read for &mut T {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+        T::read(self, buf)
+    }
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Self::Error> {
+        T::read_exact(self, buf)
+    }
+}
+
+impl<T: Write> Write for &mut T {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        T::write(self, buf)
+    }
+
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error> {
+        T::write_all(self, buf)
+    }
+
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        T::flush(self, )
+    }
+}
+
+impl<T: Seek> Seek for &mut T {
+    fn seek(&mut self, pos: SeekFrom) -> Result<u64, Self::Error> {
+        T::seek(self, pos.into())
+    }
+}
+
 pub(crate) trait ReadLeExt {
     type Error;
     fn read_u8(&mut self) -> Result<u8, Self::Error>;

src/lib.rs

@@ -21,7 +21,7 @@
 //!     let img_file = std::fs::OpenOptions::new().read(true).write(true)
 //!         .open("tmp/fat.img")?;
 //!     let buf_stream = fscommon::BufStream::new(img_file);
-//!     let fs = fatfs::FileSystem::new(buf_stream, fatfs::FsOptions::new())?;
+//!     let fs = fatfs::FileSystem::new(fatfs::StdIoWrapper::new(buf_stream), fatfs::FsOptions::new())?;
 //!     let root_dir = fs.root_dir();
 //!
 //!     // Write a file

tests/format.rs

@@ -1,7 +1,7 @@
 use std::io;
 use std::io::prelude::*;
 
-use fatfs::{DefaultTimeProvider, LossyOemCpConverter, StdIoWrapper};
+use fatfs::{DefaultTimeProvider, LossyOemCpConverter, StdIoWrapper, FsOptions};
 use fscommon::BufStream;
 
 const KB: u64 = 1024;
@@ -73,6 +73,20 @@ fn test_format_fs(opts: fatfs::FormatVolumeOptions, total_bytes: u64) -> FileSys
     fs
 }
 
+
+#[test]
+fn test_recover_fs() {
+    let _ = env_logger::builder().is_test(true).try_init();
+    let storage_vec: Vec<u8> = vec![0xD1_u8; 1024 * 1024];
+    let storage_cur = std::io::Cursor::new(storage_vec);
+    let mut disk = fatfs::StdIoWrapper::from(BufStream::new(storage_cur));
+    assert!(fatfs::FileSystem::new(&mut disk, FsOptions::new()).is_err());
+
+    fatfs::format_volume(&mut disk, fatfs::FormatVolumeOptions::new()).expect("format volume");
+
+    fatfs::FileSystem::new(&mut disk, fatfs::FsOptions::new()).expect("open fs");
+}
+
 #[test]
 fn test_format_1mb() {
     let total_bytes = MB;

tests/read.rs

@@ -1,8 +1,9 @@
 use std::fs;
 use std::io::prelude::*;
-use std::io::SeekFrom;
 use std::str;
 
+use fatfs::Seek;
+use fatfs::SeekFrom;
 use fatfs::{DefaultTimeProvider, FatType, FsOptions, LossyOemCpConverter, StdIoWrapper};
 use fscommon::BufStream;
 
@@ -17,7 +18,7 @@ fn call_with_fs<F: Fn(FileSystem) -> ()>(f: F, filename: &str) {
     let _ = env_logger::builder().is_test(true).try_init();
     let file = fs::File::open(filename).unwrap();
     let buf_file = BufStream::new(file);
-    let fs = FileSystem::new(buf_file, FsOptions::new()).unwrap();
+    let fs = FileSystem::new(buf_file.into(), FsOptions::new()).unwrap();
     f(fs);
 }
 

tests/write.rs

@@ -31,7 +31,7 @@ fn open_filesystem_rw(tmp_path: &str) -> FileSystem {
     let file = fs::OpenOptions::new().read(true).write(true).open(&tmp_path).unwrap();
     let buf_file = BufStream::new(file);
     let options = FsOptions::new().update_accessed_date(true);
-    FileSystem::new(buf_file, options).unwrap()
+    FileSystem::new(buf_file.into(), options).unwrap()
 }
 
 fn call_with_fs<F: Fn(FileSystem) -> ()>(f: F, filename: &str, test_seq: u32) {