Skip to main content

qualia_core_db/bundle/stream/index/
header.rs

1//! Header admission never casts remote offsets into resident address sizes.
2use super::{ExtentLimit, IndexError, IndexReadLimits};
3use crate::bundle::format::{BUNDLE_HEADER_SIZE, BUNDLE_MAGIC, BUNDLE_VERSION};
4use super::HmcHeaderProbe;
5
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7pub struct CheckedHeader {
8    probe: HmcHeaderProbe,
9}
10impl CheckedHeader {
11    /// Values only. Original reserved bytes are not represented in a public probe.
12    pub(crate) fn from_probe(
13        probe: HmcHeaderProbe,
14        expected_extent: u64,
15        extent_limit: ExtentLimit,
16        limits: IndexReadLimits,
17    ) -> Result<Self, IndexError> {
18        if probe.version != BUNDLE_VERSION {
19            return Err(IndexError::UnsupportedVersion(probe.version));
20        }
21        if probe.flags & !1 != 0 {
22            return Err(IndexError::Flags);
23        }
24        if probe.total_length < BUNDLE_HEADER_SIZE as u64 || probe.total_length != expected_extent {
25            return Err(IndexError::Extent);
26        }
27        if probe.total_length > extent_limit.max_logical_bytes {
28            return Err(IndexError::ExtentLimit);
29        }
30        let end = probe
31            .index_offset
32            .checked_add(probe.index_length)
33            .ok_or(IndexError::Overflow)?;
34        if probe.index_offset < BUNDLE_HEADER_SIZE as u64 || end != probe.total_length {
35            return Err(IndexError::Footer);
36        }
37        let h = Self { probe };
38        if probe.index_offset % h.alignment() != 0 {
39            return Err(IndexError::Alignment);
40        }
41        h.check_limits(limits)?;
42        Ok(h)
43    }
44    pub(crate) fn check_limits(&self, limits: IndexReadLimits) -> Result<(), IndexError> {
45        if self.probe.index_length
46            > u64::try_from(limits.index_bytes).map_err(|_| IndexError::Overflow)?
47        {
48            return Err(IndexError::EncodedLimit);
49        }
50        if u64::from(self.probe.entry_count)
51            > u64::try_from(limits.entries).map_err(|_| IndexError::Overflow)?
52        {
53            return Err(IndexError::Count);
54        }
55        Ok(())
56    }
57    pub const fn probe(&self) -> HmcHeaderProbe {
58        self.probe
59    }
60    pub const fn entry_count(&self) -> u32 {
61        self.probe.entry_count
62    }
63    pub const fn index_offset(&self) -> u64 {
64        self.probe.index_offset
65    }
66    pub const fn index_length(&self) -> u64 {
67        self.probe.index_length
68    }
69    pub const fn total_length(&self) -> u64 {
70        self.probe.total_length
71    }
72    pub const fn crc32c(&self) -> u32 {
73        self.probe.whole_file_crc32c
74    }
75    pub const fn alignment(&self) -> u64 {
76        if self.probe.flags == 1 { 4096 } else { 64 }
77    }
78}
79
80pub fn admit_header(
81    bytes: &[u8],
82    expected_extent: u64,
83    extent_limit: ExtentLimit,
84    limits: IndexReadLimits,
85) -> Result<CheckedHeader, IndexError> {
86    if bytes.len() != BUNDLE_HEADER_SIZE {
87        return Err(IndexError::HeaderLength);
88    }
89    if bytes[..4] != BUNDLE_MAGIC {
90        return Err(IndexError::BadMagic);
91    }
92    if bytes[40..64].iter().any(|b| *b != 0) {
93        return Err(IndexError::Reserved);
94    }
95    let u16_at = |n: usize| u16::from_le_bytes([bytes[n], bytes[n + 1]]);
96    let u32_at =
97        |n: usize| u32::from_le_bytes([bytes[n], bytes[n + 1], bytes[n + 2], bytes[n + 3]]);
98    let u64_at = |n: usize| {
99        u64::from_le_bytes([
100            bytes[n],
101            bytes[n + 1],
102            bytes[n + 2],
103            bytes[n + 3],
104            bytes[n + 4],
105            bytes[n + 5],
106            bytes[n + 6],
107            bytes[n + 7],
108        ])
109    };
110    CheckedHeader::from_probe(
111        HmcHeaderProbe {
112            version: u16_at(4),
113            flags: u16_at(6),
114            entry_count: u32_at(8),
115            index_offset: u64_at(12),
116            index_length: u64_at(20),
117            total_length: u64_at(28),
118            whole_file_crc32c: u32_at(36),
119        },
120        expected_extent,
121        extent_limit,
122        limits,
123    )
124}