qualia_core_db/bundle/stream/index/
header.rs1use 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 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}