fast_ntfs 1.0.1

Forked a low-level NTFS filesystem library
Documentation 
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

// Copyright 2021-2026 Colin Finck <colin@reactos.org>
// SPDX-License-Identifier: MIT OR Apache-2.0

use alloc::vec::Vec;

use crate::error::{NtfsError, Result};
use crate::io::{Read, Seek, SeekFrom};
use crate::types::NtfsPosition;

#[derive(Clone, Debug)]
struct MappedDataRun {
    start: u64,
    end: u64,
    position: NtfsPosition,
}

/// Maps logical byte ranges of a non-resident value to their filesystem positions.
#[derive(Clone, Debug)]
pub(crate) struct MappedDataRuns {
    data_size: u64,
    runs: Vec<MappedDataRun>,
}

impl MappedDataRuns {
    pub(crate) fn new(data_size: u64) -> Self {
        Self {
            data_size,
            runs: Vec::new(),
        }
    }

    /// Appends a data run, returning `false` if its logical end would overflow.
    pub(crate) fn push(&mut self, allocated_size: u64, position: NtfsPosition) -> bool {
        let start = self.runs.last().map_or(0, |run| run.end);
        let Some(end) = start.checked_add(allocated_size) else {
            return false;
        };
        self.runs.push(MappedDataRun {
            start,
            end,
            position,
        });
        true
    }

    /// Reads one logical range, stitching physical and sparse data runs into `data`.
    pub(crate) fn read_exact_at<T, F>(
        &self,
        fs: &mut T,
        offset: u64,
        data: &mut [u8],
        out_of_bounds: F,
    ) -> Result<NtfsPosition>
    where
        T: Read + Seek,
        F: Fn() -> NtfsError,
    {
        let data_len = u64::try_from(data.len()).map_err(|_| out_of_bounds())?;
        let end = offset
            .checked_add(data_len)
            .filter(|end| *end <= self.data_size)
            .ok_or_else(&out_of_bounds)?;
        let mut run_index = self.runs.partition_point(|run| run.end <= offset);
        let first_run = self
            .runs
            .get(run_index)
            .filter(|run| run.start <= offset && offset < run.end)
            .ok_or_else(&out_of_bounds)?;
        let position = first_run.position + (offset - first_run.start);
        let mut data_offset = 0usize;
        let mut stream_offset = offset;

        while stream_offset < end {
            let run = self
                .runs
                .get(run_index)
                .filter(|run| run.start <= stream_offset && stream_offset < run.end)
                .ok_or_else(&out_of_bounds)?;
            let offset_in_run = stream_offset - run.start;
            let bytes_in_run = usize::try_from(run.end - stream_offset).unwrap_or(usize::MAX);
            let bytes_to_read = bytes_in_run.min(data.len() - data_offset);
            let target = &mut data[data_offset..data_offset + bytes_to_read];
            if let Some(run_position) = (run.position + offset_in_run).value() {
                fs.seek(SeekFrom::Start(run_position.get()))?;
                fs.read_exact(target)?;
            } else {
                target.fill(0);
            }
            data_offset += bytes_to_read;
            stream_offset += bytes_to_read as u64;
            run_index += 1;
        }

        Ok(position)
    }
}