1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// Copyright 2021 Colin Finck <colin@reactos.org>
// SPDX-License-Identifier: GPL-2.0-or-later
use crate::attribute::NtfsAttributeType;
use crate::attribute_value::NtfsAttributeValue;
use crate::error::{NtfsError, Result};
use crate::index_record::NtfsIndexRecord;
use crate::ntfs::Ntfs;
use crate::structured_values::index_root::NtfsIndexRoot;
use crate::structured_values::NtfsStructuredValue;
use crate::traits::NtfsReadSeek;
use crate::types::Vcn;
use binread::io::{Read, Seek, SeekFrom};
use core::iter::FusedIterator;
#[derive(Clone, Debug)]
pub struct NtfsIndexAllocation<'n, 'f> {
ntfs: &'n Ntfs,
value: NtfsAttributeValue<'n, 'f>,
}
impl<'n, 'f> NtfsIndexAllocation<'n, 'f> {
pub fn iter(&self, index_root: &NtfsIndexRoot) -> NtfsIndexRecords<'n, 'f> {
let index_record_size = index_root.index_record_size();
NtfsIndexRecords::new(self.clone(), index_record_size)
}
pub fn record_from_vcn<T>(
&self,
fs: &mut T,
index_root: &NtfsIndexRoot,
vcn: Vcn,
) -> Result<NtfsIndexRecord<'n>>
where
T: Read + Seek,
{
// Seek to the byte offset of the given VCN.
let mut value = self.value.clone();
let offset = vcn.offset(self.ntfs)?;
value.seek(fs, SeekFrom::Current(offset))?;
if value.stream_position() >= value.len() {
return Err(NtfsError::VcnOutOfBoundsInIndexAllocation {
position: self.value.data_position().unwrap(),
vcn,
});
}
// Get the record.
let index_record_size = index_root.index_record_size();
let record = NtfsIndexRecord::new(self.ntfs, fs, value, index_record_size)?;
// Validate that the VCN in the record is the requested one.
if record.vcn() != vcn {
return Err(NtfsError::VcnMismatchInIndexAllocation {
position: self.value.data_position().unwrap(),
expected: vcn,
actual: record.vcn(),
});
}
Ok(record)
}
}
impl<'n, 'f> NtfsStructuredValue<'n, 'f> for NtfsIndexAllocation<'n, 'f> {
const TY: NtfsAttributeType = NtfsAttributeType::IndexAllocation;
fn from_attribute_value<T>(_fs: &mut T, value: NtfsAttributeValue<'n, 'f>) -> Result<Self>
where
T: Read + Seek,
{
let ntfs = match &value {
NtfsAttributeValue::AttributeListNonResident(value) => value.ntfs(),
NtfsAttributeValue::NonResident(value) => value.ntfs(),
NtfsAttributeValue::Resident(_) => {
let position = value.data_position().unwrap();
return Err(NtfsError::UnexpectedResidentAttribute { position });
}
};
Ok(Self { ntfs, value })
}
}
#[derive(Clone, Debug)]
pub struct NtfsIndexRecords<'n, 'f> {
index_allocation: NtfsIndexAllocation<'n, 'f>,
index_record_size: u32,
}
impl<'n, 'f> NtfsIndexRecords<'n, 'f> {
fn new(index_allocation: NtfsIndexAllocation<'n, 'f>, index_record_size: u32) -> Self {
Self {
index_allocation,
index_record_size,
}
}
pub fn attach<'a, T>(self, fs: &'a mut T) -> NtfsIndexRecordsAttached<'n, 'f, 'a, T>
where
T: Read + Seek,
{
NtfsIndexRecordsAttached::new(fs, self)
}
pub fn next<T>(&mut self, fs: &mut T) -> Option<Result<NtfsIndexRecord<'n>>>
where
T: Read + Seek,
{
if self.index_allocation.value.stream_position() >= self.index_allocation.value.len() {
return None;
}
// Get the current record.
let record = iter_try!(NtfsIndexRecord::new(
self.index_allocation.ntfs,
fs,
self.index_allocation.value.clone(),
self.index_record_size
));
// Advance our iterator to the next record.
iter_try!(self
.index_allocation
.value
.seek(fs, SeekFrom::Current(self.index_record_size as i64)));
Some(Ok(record))
}
}
pub struct NtfsIndexRecordsAttached<'n, 'f, 'a, T>
where
T: Read + Seek,
{
fs: &'a mut T,
index_records: NtfsIndexRecords<'n, 'f>,
}
impl<'n, 'f, 'a, T> NtfsIndexRecordsAttached<'n, 'f, 'a, T>
where
T: Read + Seek,
{
fn new(fs: &'a mut T, index_records: NtfsIndexRecords<'n, 'f>) -> Self {
Self { fs, index_records }
}
pub fn detach(self) -> NtfsIndexRecords<'n, 'f> {
self.index_records
}
}
impl<'n, 'f, 'a, T> Iterator for NtfsIndexRecordsAttached<'n, 'f, 'a, T>
where
T: Read + Seek,
{
type Item = Result<NtfsIndexRecord<'n>>;
fn next(&mut self) -> Option<Self::Item> {
self.index_records.next(self.fs)
}
}
impl<'n, 'f, 'a, T> FusedIterator for NtfsIndexRecordsAttached<'n, 'f, 'a, T> where T: Read + Seek {}
|
