Merge pull request #66 from sftse/pad-with-free

Pad with free

Author: mdsteele

src/internal/alloc.rs

@@ -92,43 +92,37 @@ impl<F> Allocator<F> {
         }
         for &difat_sector in self.difat_sector_ids.iter() {
             let difat_sector_index = difat_sector as usize;
-            if difat_sector_index >= self.fat.len() {
+            let Some(sector) = self.fat.get_mut(difat_sector_index) else {
                 malformed!(
                     "FAT has {} entries, but DIFAT lists {} as a DIFAT sector",
                     self.fat.len(),
                     difat_sector
                 );
+            };
+            if *sector != consts::DIFAT_SECTOR && validation.is_strict() {
+                malformed!(
+                    "DIFAT sector {} is not marked as such in the FAT",
+                    difat_sector
+                );
             }
-            if self.fat[difat_sector_index] != consts::DIFAT_SECTOR {
-                if validation.is_strict() {
-                    malformed!(
-                        "DIFAT sector {} is not marked as such in the FAT",
-                        difat_sector
-                    );
-                } else {
-                    self.fat[difat_sector_index] = consts::DIFAT_SECTOR;
-                }
-            }
+            *sector = consts::DIFAT_SECTOR;
         }
         for &fat_sector in self.difat.iter() {
             let fat_sector_index = fat_sector as usize;
-            if fat_sector_index >= self.fat.len() {
+            let Some(sector) = self.fat.get_mut(fat_sector_index) else {
                 malformed!(
                     "FAT has {} entries, but DIFAT lists {} as a FAT sector",
                     self.fat.len(),
                     fat_sector
                 );
+            };
+            if *sector != consts::FAT_SECTOR && validation.is_strict() {
+                malformed!(
+                    "FAT sector {} is not marked as such in the FAT",
+                    fat_sector
+                );
             }
-            if self.fat[fat_sector_index] != consts::FAT_SECTOR {
-                if validation.is_strict() {
-                    malformed!(
-                        "FAT sector {} is not marked as such in the FAT",
-                        fat_sector
-                    );
-                } else {
-                    self.fat[fat_sector_index] = consts::FAT_SECTOR;
-                }
-            }
+            *sector = consts::FAT_SECTOR;
         }
         let mut pointees = FnvHashSet::default();
         for (from_sector, &to_sector) in self.fat.iter().enumerate() {

src/internal/consts.rs

@@ -33,4 +33,75 @@ pub const ROOT_STREAM_ID: u32 = 0;
 pub const MAX_REGULAR_STREAM_ID: u32 = 0xfffffffa;
 pub const NO_STREAM: u32 = 0xffffffff;
 
+pub(crate) fn prettify(sectors: &[u32]) -> Vec<Type> {
+    let mut fmt = Vec::new();
+    for s in sectors.iter() {
+        match *s {
+            END_OF_CHAIN => fmt.push(Type::End),
+            FREE_SECTOR => fmt.push(Type::Free),
+            DIFAT_SECTOR => fmt.push(Type::Difat),
+            FAT_SECTOR => fmt.push(Type::Fat),
+            i => {
+                if let Some(Type::Range(_, end)) = fmt.last_mut() {
+                    if *end + 1 == i {
+                        *end += 1;
+                        continue;
+                    }
+                }
+                fmt.push(Type::Range(i, i));
+            }
+        };
+    }
+    fmt
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub(crate) enum Type {
+    Free,
+    End,
+    Fat,
+    Difat,
+    Range(u32, u32),
+}
+
+impl std::fmt::Debug for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Type::Range(start, end) if *start == *end => write!(f, "{start}"),
+            Type::Range(start, end) => write!(f, "{start}-{end}"),
+            Type::Free => f.write_str("FREE"),
+            Type::End => f.write_str("EOC"),
+            Type::Fat => f.write_str("FAT"),
+            Type::Difat => f.write_str("DIFAT"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_prettify_sectors() {
+        let sectors = [
+            END_OF_CHAIN,
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            END_OF_CHAIN,
+            23,
+            25,
+            18,
+            FREE_SECTOR,
+        ];
+        let s = prettify(&sectors);
+        assert_eq!("[EOC, 0-7, EOC, 23, 25, 18, FREE]", format!("{s:?}"));
+    }
+}
+
 // ========================================================================= //

src/internal/header.rs

@@ -1,11 +1,12 @@
+use std::fmt;
 use std::io::{self, Read, Write};
 
 use crate::internal::{consts, Validation, Version};
 use crate::{ReadLeNumber, WriteLeNumber};
 
 //===========================================================================//
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct Header {
     pub version: Version,
     pub num_dir_sectors: u32,
@@ -18,6 +19,47 @@ pub struct Header {
     pub initial_difat_entries: [u32; consts::NUM_DIFAT_ENTRIES_IN_HEADER],
 }
 
+struct Sector(u32);
+
+impl fmt::Debug for Sector {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.0 {
+            consts::FREE_SECTOR => f.write_str("FREE"),
+            consts::END_OF_CHAIN => f.write_str("EOC"),
+            consts::DIFAT_SECTOR => f.write_str("DIFAT"),
+            consts::FAT_SECTOR => f.write_str("FAT"),
+            i => write!(f, "{i}"),
+        }
+    }
+}
+
+impl fmt::Debug for Header {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let start_nonfree = self
+            .initial_difat_entries
+            .iter()
+            .rev()
+            .skip_while(|elt| **elt == consts::FREE_SECTOR)
+            .count();
+        f.debug_struct("Header")
+            .field("version", &self.version)
+            .field("num_dir_sectors", &self.num_dir_sectors)
+            .field("num_fat_sectors", &self.num_fat_sectors)
+            .field("first_dir_sector", &Sector(self.first_dir_sector))
+            .field("first_minifat_sector", &Sector(self.first_minifat_sector))
+            .field("num_minifat_sectors", &self.num_minifat_sectors)
+            .field("first_difat_sector", &Sector(self.first_difat_sector))
+            .field("num_difat_sectors", &self.num_difat_sectors)
+            .field(
+                "initial_difat_entries",
+                &consts::prettify(
+                    &self.initial_difat_entries[..start_nonfree],
+                ),
+            )
+            .finish()
+    }
+}
+
 impl Header {
     pub fn read_from<R: Read>(
         reader: &mut R,

src/lib.rs

@@ -500,13 +500,16 @@ impl<F: Read + Seek> CompoundFile<F> {
         // case above, we can remove these even if it makes the number of FAT
         // entries less than the number of sectors in the file; the allocator
         // will implicitly treat these extra sectors as free.
-        while fat.last() == Some(&consts::FREE_SECTOR)
+        while fat.len() > sectors.num_sectors() as usize && fat.last() == Some(&consts::FREE_SECTOR)
             // strip DIFAT_SECTOR from the end
             || !validation.is_strict()
                 && fat.len() > sectors.num_sectors() as usize && fat.last() == Some(&consts::DIFAT_SECTOR)
         {
             fat.pop();
         }
+        while fat.len() < sectors.num_sectors() as usize {
+            fat.push(consts::FREE_SECTOR);
+        }
 
         let mut allocator =
             Allocator::new(sectors, difat_sector_ids, difat, fat, validation)?;