Pass an `&'n Ntfs` reference to `NewNtfsStructuredValue::new`

This enables all structured values to access filesystem-wide information such as the cluster size, which will soon be needed for `NtfsIndexAllocation`.

11 files changed, 88 insertions, 25 deletions

diff --git a/src/attribute.rs b/src/attribute.rs
index 2d2bdc5..1b82a36 100644
--- a/src/attribute.rs
+++ b/src/attribute.rs
@@ -233,33 +233,33 @@ impl<'n> NtfsAttribute<'n> {
 
         match self.ty()? {
             NtfsAttributeType::StandardInformation => {
-                let inner = NtfsStandardInformation::new(fs, value, length)?;
+                let inner = NtfsStandardInformation::new(self.ntfs, fs, value, length)?;
                 Ok(NtfsStructuredValue::StandardInformation(inner))
             }
             NtfsAttributeType::AttributeList => panic!("TODO"),
             NtfsAttributeType::FileName => {
-                let inner = NtfsFileName::new(fs, value, length)?;
+                let inner = NtfsFileName::new(self.ntfs, fs, value, length)?;
                 Ok(NtfsStructuredValue::FileName(inner))
             }
             NtfsAttributeType::ObjectId => {
-                let inner = NtfsObjectId::new(fs, value, length)?;
+                let inner = NtfsObjectId::new(self.ntfs, fs, value, length)?;
                 Ok(NtfsStructuredValue::ObjectId(inner))
             }
             NtfsAttributeType::SecurityDescriptor => panic!("TODO"),
             NtfsAttributeType::VolumeName => {
-                let inner = NtfsVolumeName::new(fs, value, length)?;
+                let inner = NtfsVolumeName::new(self.ntfs, fs, value, length)?;
                 Ok(NtfsStructuredValue::VolumeName(inner))
             }
             NtfsAttributeType::VolumeInformation => {
-                let inner = NtfsVolumeInformation::new(fs, value, length)?;
+                let inner = NtfsVolumeInformation::new(self.ntfs, fs, value, length)?;
                 Ok(NtfsStructuredValue::VolumeInformation(inner))
             }
             NtfsAttributeType::IndexRoot => {
-                let inner = NtfsIndexRoot::new(fs, value, length)?;
+                let inner = NtfsIndexRoot::new(self.ntfs, fs, value, length)?;
                 Ok(NtfsStructuredValue::IndexRoot(inner))
             }
             NtfsAttributeType::IndexAllocation => {
-                let inner = NtfsIndexAllocation::new(fs, value, length)?;
+                let inner = NtfsIndexAllocation::new(self.ntfs, fs, value, length)?;
                 Ok(NtfsStructuredValue::IndexAllocation(inner))
             }
             ty => Err(NtfsError::UnsupportedStructuredValue {
diff --git a/src/index_entry.rs b/src/index_entry.rs
index 65b24e3..f1a3ad3 100644
--- a/src/index_entry.rs
+++ b/src/index_entry.rs
@@ -3,6 +3,7 @@
 
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::Result;
+use crate::ntfs::Ntfs;
 use crate::structured_values::NewNtfsStructuredValue;
 use crate::traits::NtfsReadSeek;
 use binread::io::{Read, Seek, SeekFrom};
@@ -28,6 +29,7 @@ pub struct NtfsIndexEntry<'n, K>
 where
     K: NewNtfsStructuredValue<'n>,
 {
+    ntfs: &'n Ntfs,
     header: IndexEntryHeader,
     value: NtfsAttributeValue<'n>,
     key_type: PhantomData<K>,
@@ -46,7 +48,7 @@ impl<'n, K> NtfsIndexEntry<'n, K>
 where
     K: NewNtfsStructuredValue<'n>,
 {
-    pub(crate) fn new<T>(fs: &mut T, value: NtfsAttributeValue<'n>) -> Result<Self>
+    pub(crate) fn new<T>(ntfs: &'n Ntfs, fs: &mut T, value: NtfsAttributeValue<'n>) -> Result<Self>
     where
         T: Read + Seek,
     {
@@ -55,6 +57,7 @@ where
         let key_type = PhantomData;
 
         let entry = Self {
+            ntfs,
             header,
             value,
             key_type,
@@ -90,7 +93,7 @@ where
         iter_try!(value.seek(fs, SeekFrom::Current(INDEX_ENTRY_HEADER_SIZE)));
         let length = self.header.key_length as u64;
 
-        let structured_value = iter_try!(K::new(fs, value, length));
+        let structured_value = iter_try!(K::new(self.ntfs, fs, value, length));
         Some(Ok(structured_value))
     }
 
@@ -120,6 +123,7 @@ pub struct NtfsIndexEntries<'n, K>
 where
     K: NewNtfsStructuredValue<'n>,
 {
+    ntfs: &'n Ntfs,
     value: NtfsAttributeValue<'n>,
     end: u64,
     key_type: PhantomData<K>,
@@ -129,11 +133,12 @@ impl<'n, K> NtfsIndexEntries<'n, K>
 where
     K: NewNtfsStructuredValue<'n>,
 {
-    pub(crate) fn new(value: NtfsAttributeValue<'n>, end: u64) -> Self {
+    pub(crate) fn new(ntfs: &'n Ntfs, value: NtfsAttributeValue<'n>, end: u64) -> Self {
         debug_assert!(end <= value.len());
         let key_type = PhantomData;
 
         Self {
+            ntfs,
             value,
             end,
             key_type,
@@ -156,7 +161,7 @@ where
         }
 
         // Get the current entry.
-        let entry = iter_try!(NtfsIndexEntry::new(fs, self.value.clone()));
+        let entry = iter_try!(NtfsIndexEntry::new(self.ntfs, fs, self.value.clone()));
 
         if entry.flags().contains(NtfsIndexEntryFlags::LAST_ENTRY) {
             // This is the last entry.
diff --git a/src/index_record.rs b/src/index_record.rs
index fec6e09..2a49cb9 100644
--- a/src/index_record.rs
+++ b/src/index_record.rs
@@ -4,6 +4,7 @@
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::{NtfsError, Result};
 use crate::index_entry::NtfsIndexEntries;
+use crate::ntfs::Ntfs;
 use crate::record::RecordHeader;
 use crate::structured_values::NewNtfsStructuredValue;
 use crate::traits::NtfsReadSeek;
@@ -33,6 +34,7 @@ pub(crate) struct IndexNodeHeader {
 
 #[derive(Clone, Debug)]
 pub struct NtfsIndexRecord<'n> {
+    ntfs: &'n Ntfs,
     value: NtfsAttributeValue<'n>,
     index_record_header: IndexRecordHeader,
     index_node_header: IndexNodeHeader,
@@ -42,6 +44,7 @@ const HAS_SUBNODES_FLAG: u8 = 0x01;
 
 impl<'n> NtfsIndexRecord<'n> {
     pub(crate) fn new<T>(
+        ntfs: &'n Ntfs,
         fs: &mut T,
         value: NtfsAttributeValue<'n>,
         index_record_size: u32,
@@ -54,6 +57,7 @@ impl<'n> NtfsIndexRecord<'n> {
         let index_node_header = value_attached.read_le::<IndexNodeHeader>()?;
 
         let index_record = Self {
+            ntfs,
             value,
             index_record_header,
             index_node_header,
@@ -76,7 +80,7 @@ impl<'n> NtfsIndexRecord<'n> {
         let mut value = self.value.clone();
         value.seek(fs, SeekFrom::Start(start))?;
 
-        Ok(NtfsIndexEntries::new(value, end))
+        Ok(NtfsIndexEntries::new(self.ntfs, value, end))
     }
 
     /// Returns whether this index node has sub-nodes.
diff --git a/src/structured_values/file_name.rs b/src/structured_values/file_name.rs
index 963896c..dd88a15 100644
--- a/src/structured_values/file_name.rs
+++ b/src/structured_values/file_name.rs
@@ -4,6 +4,7 @@
 use crate::attribute::NtfsAttributeType;
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::{NtfsError, Result};
+use crate::ntfs::Ntfs;
 use crate::string::NtfsString;
 use crate::structured_values::{NewNtfsStructuredValue, NtfsFileAttributeFlags};
 use crate::time::NtfsTime;
@@ -122,7 +123,12 @@ impl<'n> NtfsFileName<'n> {
 }
 
 impl<'n> NewNtfsStructuredValue<'n> for NtfsFileName<'n> {
-    fn new<T>(fs: &mut T, value: NtfsAttributeValue<'n>, length: u64) -> Result<Self>
+    fn new<T>(
+        _ntfs: &'n Ntfs,
+        fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek,
     {
diff --git a/src/structured_values/index_allocation.rs b/src/structured_values/index_allocation.rs
index 24d9e27..e826590 100644
--- a/src/structured_values/index_allocation.rs
+++ b/src/structured_values/index_allocation.rs
@@ -4,6 +4,7 @@
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::Result;
 use crate::index_record::NtfsIndexRecord;
+use crate::ntfs::Ntfs;
 use crate::structured_values::index_root::NtfsIndexRoot;
 use crate::structured_values::NewNtfsStructuredValue;
 use crate::traits::NtfsReadSeek;
@@ -12,34 +13,42 @@ use core::iter::FusedIterator;
 
 #[derive(Clone, Debug)]
 pub struct NtfsIndexAllocation<'n> {
+    ntfs: &'n Ntfs,
     value: NtfsAttributeValue<'n>,
 }
 
 impl<'n> NtfsIndexAllocation<'n> {
-    pub fn iter(&self, index_root: &NtfsIndexRoot) -> NtfsIndexRecords<'n> {
+    pub fn iter(&self, index_root: &NtfsIndexRoot<'n>) -> NtfsIndexRecords<'n> {
         let index_record_size = index_root.index_record_size();
-        NtfsIndexRecords::new(self.value.clone(), index_record_size)
+        NtfsIndexRecords::new(self.ntfs, self.value.clone(), index_record_size)
     }
 }
 
 impl<'n> NewNtfsStructuredValue<'n> for NtfsIndexAllocation<'n> {
-    fn new<T>(_fs: &mut T, value: NtfsAttributeValue<'n>, _length: u64) -> Result<Self>
+    fn new<T>(
+        ntfs: &'n Ntfs,
+        _fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        _length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek,
     {
-        Ok(Self { value })
+        Ok(Self { ntfs, value })
     }
 }
 
 #[derive(Clone, Debug)]
 pub struct NtfsIndexRecords<'n> {
+    ntfs: &'n Ntfs,
     value: NtfsAttributeValue<'n>,
     index_record_size: u32,
 }
 
 impl<'n> NtfsIndexRecords<'n> {
-    fn new(value: NtfsAttributeValue<'n>, index_record_size: u32) -> Self {
+    fn new(ntfs: &'n Ntfs, value: NtfsAttributeValue<'n>, index_record_size: u32) -> Self {
         Self {
+            ntfs,
             value,
             index_record_size,
         }
@@ -62,6 +71,7 @@ impl<'n> NtfsIndexRecords<'n> {
 
         // Get the current record.
         let record = iter_try!(NtfsIndexRecord::new(
+            self.ntfs,
             fs,
             self.value.clone(),
             self.index_record_size
diff --git a/src/structured_values/index_root.rs b/src/structured_values/index_root.rs
index 5a97cda..47b52d6 100644
--- a/src/structured_values/index_root.rs
+++ b/src/structured_values/index_root.rs
@@ -6,6 +6,7 @@ use crate::attribute_value::NtfsAttributeValue;
 use crate::error::{NtfsError, Result};
 use crate::index_entry::NtfsIndexEntries;
 use crate::index_record::{IndexNodeHeader, INDEX_NODE_HEADER_SIZE};
+use crate::ntfs::Ntfs;
 use crate::structured_values::NewNtfsStructuredValue;
 use crate::traits::NtfsReadSeek;
 use binread::io::{Read, Seek, SeekFrom};
@@ -24,6 +25,7 @@ struct IndexRootHeader {
 
 #[derive(Clone, Debug)]
 pub struct NtfsIndexRoot<'n> {
+    ntfs: &'n Ntfs,
     value: NtfsAttributeValue<'n>,
     index_root_header: IndexRootHeader,
     index_node_header: IndexNodeHeader,
@@ -48,7 +50,7 @@ impl<'n> NtfsIndexRoot<'n> {
         let mut value = self.value.clone();
         value.seek(fs, SeekFrom::Start(start))?;
 
-        Ok(NtfsIndexEntries::new(value, end))
+        Ok(NtfsIndexEntries::new(self.ntfs, value, end))
     }
 
     pub fn index_record_size(&self) -> u32 {
@@ -68,7 +70,12 @@ impl<'n> NtfsIndexRoot<'n> {
 }
 
 impl<'n> NewNtfsStructuredValue<'n> for NtfsIndexRoot<'n> {
-    fn new<T>(fs: &mut T, value: NtfsAttributeValue<'n>, _length: u64) -> Result<Self>
+    fn new<T>(
+        ntfs: &'n Ntfs,
+        fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        _length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek,
     {
@@ -87,6 +94,7 @@ impl<'n> NewNtfsStructuredValue<'n> for NtfsIndexRoot<'n> {
         let index_node_header = value_attached.read_le::<IndexNodeHeader>()?;
 
         Ok(Self {
+            ntfs,
             value,
             index_root_header,
             index_node_header,
diff --git a/src/structured_values/mod.rs b/src/structured_values/mod.rs
index b61f24b..ce97f63 100644
--- a/src/structured_values/mod.rs
+++ b/src/structured_values/mod.rs
@@ -23,6 +23,7 @@ pub use volume_name::*;
 
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::Result;
+use crate::ntfs::Ntfs;
 use binread::io::{Read, Seek};
 use bitflags::bitflags;
 
@@ -56,7 +57,12 @@ pub enum NtfsStructuredValue<'n> {
 }
 
 pub trait NewNtfsStructuredValue<'n>: Sized {
-    fn new<T>(fs: &mut T, value: NtfsAttributeValue<'n>, length: u64) -> Result<Self>
+    fn new<T>(
+        ntfs: &'n Ntfs,
+        fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek;
 }
diff --git a/src/structured_values/object_id.rs b/src/structured_values/object_id.rs
index 98785e6..f9c84aa 100644
--- a/src/structured_values/object_id.rs
+++ b/src/structured_values/object_id.rs
@@ -5,6 +5,7 @@ use crate::attribute::NtfsAttributeType;
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::{NtfsError, Result};
 use crate::guid::{NtfsGuid, GUID_SIZE};
+use crate::ntfs::Ntfs;
 use crate::structured_values::NewNtfsStructuredValue;
 use binread::io::{Read, Seek};
 use binread::BinReaderExt;
@@ -36,7 +37,12 @@ impl NtfsObjectId {
 }
 
 impl<'n> NewNtfsStructuredValue<'n> for NtfsObjectId {
-    fn new<T>(fs: &mut T, value: NtfsAttributeValue<'n>, length: u64) -> Result<Self>
+    fn new<T>(
+        _ntfs: &'n Ntfs,
+        fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek,
     {
diff --git a/src/structured_values/standard_information.rs b/src/structured_values/standard_information.rs
index a596d2c..07849f6 100644
--- a/src/structured_values/standard_information.rs
+++ b/src/structured_values/standard_information.rs
@@ -4,6 +4,7 @@
 use crate::attribute::NtfsAttributeType;
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::{NtfsError, Result};
+use crate::ntfs::Ntfs;
 use crate::structured_values::{NewNtfsStructuredValue, NtfsFileAttributeFlags};
 use crate::time::NtfsTime;
 use binread::io::{Read, Seek};
@@ -92,7 +93,12 @@ impl NtfsStandardInformation {
 }
 
 impl<'n> NewNtfsStructuredValue<'n> for NtfsStandardInformation {
-    fn new<T>(fs: &mut T, value: NtfsAttributeValue<'n>, length: u64) -> Result<Self>
+    fn new<T>(
+        _ntfs: &'n Ntfs,
+        fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek,
     {
diff --git a/src/structured_values/volume_information.rs b/src/structured_values/volume_information.rs
index 9efd1c6..76ae2e3 100644
--- a/src/structured_values/volume_information.rs
+++ b/src/structured_values/volume_information.rs
@@ -4,6 +4,7 @@
 use crate::attribute::NtfsAttributeType;
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::{NtfsError, Result};
+use crate::ntfs::Ntfs;
 use crate::structured_values::NewNtfsStructuredValue;
 use binread::io::{Read, Seek};
 use binread::{BinRead, BinReaderExt};
@@ -54,7 +55,12 @@ impl NtfsVolumeInformation {
 }
 
 impl<'n> NewNtfsStructuredValue<'n> for NtfsVolumeInformation {
-    fn new<T>(fs: &mut T, value: NtfsAttributeValue<'n>, length: u64) -> Result<Self>
+    fn new<T>(
+        _ntfs: &'n Ntfs,
+        fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek,
     {
diff --git a/src/structured_values/volume_name.rs b/src/structured_values/volume_name.rs
index ba126e4..8d75c04 100644
--- a/src/structured_values/volume_name.rs
+++ b/src/structured_values/volume_name.rs
@@ -4,6 +4,7 @@
 use crate::attribute::NtfsAttributeType;
 use crate::attribute_value::NtfsAttributeValue;
 use crate::error::{NtfsError, Result};
+use crate::ntfs::Ntfs;
 use crate::string::NtfsString;
 use crate::structured_values::NewNtfsStructuredValue;
 use binread::io::{Read, Seek};
@@ -41,7 +42,12 @@ impl<'n> NtfsVolumeName<'n> {
 }
 
 impl<'n> NewNtfsStructuredValue<'n> for NtfsVolumeName<'n> {
-    fn new<T>(_fs: &mut T, value: NtfsAttributeValue<'n>, length: u64) -> Result<Self>
+    fn new<T>(
+        _ntfs: &'n Ntfs,
+        _fs: &mut T,
+        value: NtfsAttributeValue<'n>,
+        length: u64,
+    ) -> Result<Self>
     where
         T: Read + Seek,
     {