Add tag iter

Author: nicholasbishop

src/error.rs

@@ -250,9 +250,6 @@ pub(crate) enum CorruptKind {
     /// Journal descriptor tag checksum is invalid.
     JournalDescriptorTagChecksum,
 
-    /// Not enough bytes to read a journal descriptor tag.
-    JournalDescriptorTagTruncated,
-
     /// Journal has a descriptor block that contains no tag with the last-tag flag set.
     JournalDescriptorBlockMissingLastTag,
 
@@ -359,9 +356,6 @@ impl Display for CorruptKind {
             Self::JournalDescriptorTagChecksum => {
                 write!(f, "journal descriptor tag checksum is invalid")
             }
-            Self::JournalDescriptorTagTruncated => {
-                write!(f, "journal descriptor tag truncated")
-            }
             Self::JournalDescriptorBlockMissingLastTag => write!(
                 f,
                 "a journal descriptor block has no tag with the last-tag flag set"

src/journal.rs

@@ -20,7 +20,7 @@ use alloc::collections::BTreeMap;
 use alloc::vec;
 use block_header::{JournalBlockHeader, JournalBlockType};
 use descriptor_block::{
-    is_descriptor_block_checksum_valid, DescriptorBlockTag,
+    is_descriptor_block_checksum_valid, DescriptorBlockTagIter,
 };
 use superblock::JournalSuperblock;
 
@@ -91,6 +91,7 @@ fn load_block_map(
     // journal when bad data is encountered.
 
     let mut block = vec![0; fs.0.superblock.block_size.to_usize()];
+    let mut data_block = vec![0; fs.0.superblock.block_size.to_usize()];
     let mut block_map = BTreeMap::new();
     let mut uncommitted_block_map = BTreeMap::new();
     let mut sequence = superblock.sequence;
@@ -114,19 +115,21 @@ fn load_block_map(
                 return Err(CorruptKind::JournalDescriptorBlockChecksum.into());
             }
 
-            let tags =
-                DescriptorBlockTag::read_bytes_to_vec(&block[12..]).unwrap();
+            let tags = DescriptorBlockTagIter::new(&block[12..]);
+
+            for tag in tags {
+                let tag = tag?;
 
-            for tag in &tags {
                 let block_index = journal_block_iter
                     .next()
                     .ok_or(CorruptKind::JournalTruncated)??;
 
+                // Check the data block checksum.
                 let mut checksum = Checksum::new();
                 checksum.update(superblock.uuid.as_bytes());
                 checksum.update_u32_be(sequence);
-                fs.read_from_block(block_index, 0, &mut block)?;
-                checksum.update(&block);
+                fs.read_from_block(block_index, 0, &mut data_block)?;
+                checksum.update(&data_block);
                 if checksum.finalize() != tag.checksum {
                     return Err(
                         CorruptKind::JournalDescriptorTagChecksum.into()

src/journal/descriptor_block.rs

@@ -10,7 +10,6 @@ use crate::checksum::Checksum;
 use crate::error::{CorruptKind, Ext4Error};
 use crate::journal::superblock::JournalSuperblock;
 use crate::util::{read_u32be, u64_from_hilo};
-use alloc::vec::Vec;
 use bitflags::bitflags;
 
 pub(super) fn is_descriptor_block_checksum_valid(
@@ -54,14 +53,14 @@ impl DescriptorBlockTag {
         }
     }
 
-    pub(super) fn read_bytes(bytes: &[u8]) -> Result<Self, Ext4Error> {
+    pub(super) fn read_bytes(bytes: &[u8]) -> Option<Self> {
         // Note: the tag format depends on feature flags in the journal
         // superblock. The code in this function is only correct if the
         // `CHECKSUM_V3` feature is enabled (this is checked when
         // loading the superblock).
 
         if bytes.len() < Self::SIZE_WITHOUT_UUID {
-            return Err(CorruptKind::JournalDescriptorTagTruncated.into());
+            return None;
         }
 
         let t_blocknr = read_u32be(bytes, 0);
@@ -74,42 +73,67 @@ impl DescriptorBlockTag {
         if !flags.contains(DescriptorBlockTagFlags::UUID_OMITTED)
             && bytes.len() < Self::SIZE_WITH_UUID
         {
-            return Err(CorruptKind::JournalDescriptorTagTruncated.into());
+            return None;
         }
 
-        Ok(Self {
+        Some(Self {
             block_number: u64_from_hilo(t_blocknr_high, t_blocknr),
             flags,
             checksum: t_checksum,
         })
     }
+}
+
+pub(super) struct DescriptorBlockTagIter<'a> {
+    bytes: &'a [u8],
+    is_done: bool,
+}
 
-    // TODO: this could be an iterator instead of allocating.
-    pub(super) fn read_bytes_to_vec(
-        mut bytes: &[u8],
-    ) -> Result<Vec<Self>, Ext4Error> {
-        let mut v = Vec::new();
+impl<'a> DescriptorBlockTagIter<'a> {
+    pub(super) fn new(bytes: &'a [u8]) -> Self {
+        Self {
+            bytes,
+            is_done: false,
+        }
+    }
+}
 
-        while !bytes.is_empty() {
-            let tag = Self::read_bytes(bytes)?;
-            let is_end = tag.flags.contains(DescriptorBlockTagFlags::LAST_TAG);
-            let size = tag.encoded_size();
-            v.push(tag);
+impl Iterator for DescriptorBlockTagIter<'_> {
+    type Item = Result<DescriptorBlockTag, Ext4Error>;
 
-            if is_end {
-                return Ok(v);
-            }
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.is_done {
+            return None;
+        }
 
-            bytes = &bytes[size..];
+        let tag = if let Some(tag) = DescriptorBlockTag::read_bytes(self.bytes)
+        {
+            tag
+        } else {
+            // If there were not enough bytes left to read the next tag,
+            // then the expected tag with the LAST_TAG flag set is missing.
+            self.is_done = true;
+            return Some(Err(
+                CorruptKind::JournalDescriptorBlockMissingLastTag.into(),
+            ));
+        };
+
+        if tag.flags.contains(DescriptorBlockTagFlags::LAST_TAG) {
+            // Last tag reached, nothing more to read.
+            self.is_done = true;
+            return Some(Ok(tag));
         }
 
-        Err(CorruptKind::JournalDescriptorBlockMissingLastTag.into())
+        // Update the remaining bytes.
+        self.bytes = &self.bytes[tag.encoded_size()..];
+
+        Some(Ok(tag))
     }
 }
 
 bitflags! {
     #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
-    pub struct DescriptorBlockTagFlags: u32 {
+    pub(crate) struct DescriptorBlockTagFlags: u32 {
         const ESCAPED = 0x1;
         const UUID_OMITTED = 0x2;
         const DELETED = 0x4;
@@ -128,10 +152,6 @@ mod tests {
     #[test]
     fn test_journal_descriptor_block_tags() {
         let mut bytes = vec![];
-        assert_eq!(
-            DescriptorBlockTag::read_bytes_to_vec(&bytes).unwrap_err(),
-            CorruptKind::JournalDescriptorBlockMissingLastTag
-        );
 
         // Block number low.
         push_u32be(&mut bytes, 0x1000);
@@ -154,8 +174,10 @@ mod tests {
         bytes.extend([0; 16]);
 
         assert_eq!(
-            DescriptorBlockTag::read_bytes_to_vec(&bytes).unwrap(),
-            vec![
+            DescriptorBlockTagIter::new(&bytes)
+                .map(Result::unwrap)
+                .collect::<Vec<_>>(),
+            [
                 DescriptorBlockTag {
                     block_number: 0xa000_0000_1000,
                     flags: DescriptorBlockTagFlags::UUID_OMITTED,