Skip to main content

qualia_core_db/bundle/stream/selection/
entry.rs

1use 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/// Actual committed row from the current plaintext/epoch0 descriptor profile.
36/// Its private provenance associates signed bytes; it never grants current rights.
37#[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    /// Exact association only; this does not recheck pins, expiry or any grant.
82    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}