qualia_core_db/bundle/stream/selection/
entry.rs1use crate::bundle::stream::{
2 descriptor::{
3 decode_body, decode_entry_page, domain_digest, CandidateIdentity, DescriptorError,
4 DigestDomain, EntryRecord, SourceCommit, MAX_ENTRIES,
5 },
6 index::{admit_header, AdmittedIndex, ExtentLimit, IndexError, IndexReadLimits},
7 policy::BoundClosure,
8 proof::{empty_root, ProofError, Representation, TreeSpec},
9};
10use crate::crypto::network::digest::sha384;
11use crate::net::qdnf::types::StrongDigest;
12#[derive(Clone, Copy, Debug, PartialEq, Eq)]
13pub enum SelectionError {
14 IdentityMismatch,
15 Bounds,
16 Descriptor(DescriptorError),
17 Index(IndexError),
18 Proof(ProofError),
19}
20impl From<DescriptorError> for SelectionError {
21 fn from(e: DescriptorError) -> Self {
22 Self::Descriptor(e)
23 }
24}
25impl From<IndexError> for SelectionError {
26 fn from(e: IndexError) -> Self {
27 Self::Index(e)
28 }
29}
30impl From<ProofError> for SelectionError {
31 fn from(e: ProofError) -> Self {
32 Self::Proof(e)
33 }
34}
35#[derive(Clone, Copy, Debug)]
38pub struct SelectedPlainEntry<'p> {
39 candidate: CandidateIdentity,
40 row: EntryRecord<'p>,
41 source: SourceCommit,
42}
43impl<'p> SelectedPlainEntry<'p> {
44 pub const fn candidate_identity(&self) -> CandidateIdentity {
45 self.candidate
46 }
47 pub const fn entry_id(&self) -> u32 {
48 self.row.id
49 }
50 pub const fn ordinal(&self) -> u32 {
51 self.row.ordinal
52 }
53 pub const fn kind(&self) -> &'p str {
54 self.row.kind
55 }
56 pub const fn inner_version(&self) -> u64 {
57 self.row.inner_version
58 }
59 pub const fn offset(&self) -> u64 {
60 self.row.offset
61 }
62 pub const fn logical_length(&self) -> u64 {
63 self.row.length
64 }
65 pub const fn root(&self) -> StrongDigest {
66 self.row.root
67 }
68 pub const fn source_commit(&self) -> SourceCommit {
69 self.source
70 }
71 pub fn tree_spec(&self) -> Result<TreeSpec, SelectionError> {
72 Ok(TreeSpec::new(
73 self.candidate.context_id(),
74 self.row.id,
75 self.candidate.generation(),
76 Representation::Plaintext,
77 0,
78 self.row.length,
79 )?)
80 }
81 pub fn check_closure(&self, closure: &BoundClosure<'_>) -> Result<(), SelectionError> {
83 if self.candidate != closure.identity() {
84 return Err(SelectionError::IdentityMismatch);
85 }
86 Ok(())
87 }
88}
89#[allow(clippy::too_many_arguments)]
90pub fn select_entry<'p>(
91 closure: &BoundClosure<'_>,
92 body_bytes: &[u8],
93 raw_header: &[u8],
94 index: &AdmittedIndex<'_>,
95 entry_page: &'p [u8],
96 ordinal: u32,
97 rows: &mut [EntryRecord<'p>],
98 framing: &mut [u8],
99) -> Result<SelectedPlainEntry<'p>, SelectionError> {
100 use SelectionError as E;
101 let body = decode_body(body_bytes)?;
102 let candidate = closure.identity();
103 if domain_digest(DigestDomain::Body, body_bytes, framing)? != candidate.descriptor_id()
104 || body.context_id() != candidate.context_id()
105 || domain_digest(
106 DigestDomain::Context,
107 body.context().encoded_bytes(),
108 framing,
109 )? != candidate.context_id()
110 || body.context().parameters().generation != candidate.generation()
111 || body.context().entry_count() != candidate.entry_count() as usize
112 {
113 return Err(E::IdentityMismatch);
114 }
115 let source = body.context().source();
116 let limits = IndexReadLimits {
117 index_bytes: index.encoded_bytes().len(),
118 entries: MAX_ENTRIES,
119 ..IndexReadLimits::default()
120 };
121 let header = admit_header(raw_header, source.length, ExtentLimit::default(), limits)?;
122 if header.probe() != index.header().probe()
123 || source.version != header.probe().version
124 || source.flags != header.probe().flags
125 || source.index_offset != header.index_offset()
126 || source.index_length != header.index_length()
127 || header.entry_count() as usize != body.context().entry_count()
128 || sha384(raw_header) != source.header_digest
129 || sha384(index.encoded_bytes()) != source.index_digest
130 {
131 return Err(E::IdentityMismatch);
132 }
133 let h = decode_entry_page(entry_page, rows)?;
134 let want = body.page_refs().get(h.number as usize)?;
135 if h.context != candidate.context_id()
136 || h.first != want.first
137 || h.rows != want.rows as usize
138 || entry_page.len() != want.encoded_length as usize
139 || domain_digest(DigestDomain::EntryPage, entry_page, framing)? != want.digest
140 {
141 return Err(E::IdentityMismatch);
142 }
143 let local = ordinal.checked_sub(h.first).ok_or(E::Bounds)? as usize;
144 let row = *rows
145 .get(local)
146 .filter(|_| local < h.rows)
147 .ok_or(E::Bounds)?;
148 let actual = index.entries().nth(ordinal as usize).ok_or(E::Bounds)??;
149 if row.ordinal != ordinal
150 || row.offset != actual.offset()
151 || row.length != actual.length()
152 || row.kind != actual.kind()
153 {
154 return Err(E::IdentityMismatch);
155 }
156 let selected = SelectedPlainEntry {
157 candidate,
158 row,
159 source,
160 };
161 if row.length == 0 && empty_root(&selected.tree_spec()?)? != row.root {
162 return Err(E::IdentityMismatch);
163 }
164 Ok(selected)
165}