Skip to main content

qualia_core_db/bundle/stream/descriptor/
roots.rs

1use super::cbor::{R, W, encode};
2use super::refs::{PageRefsView, read_refs, write_refs};
3use super::{
4    ContextParameters, DescriptorError as E, LEAF_BYTES, MAX_ENTRIES, PageRef, SourceCommit,
5};
6use crate::net::qdnf::types::StrongDigest;
7pub struct ContextInput<'a> {
8    pub parameters: ContextParameters,
9    pub source: SourceCommit,
10    pub entries: usize,
11    pub pages: &'a [PageRef],
12}
13#[derive(Clone, Copy)]
14pub struct ContextView<'a> {
15    pub(crate) encoded: &'a [u8],
16    pub(crate) parameters: ContextParameters,
17    pub(crate) source: SourceCommit,
18    pub(crate) entries: usize,
19    pub(crate) pages: PageRefsView<'a>,
20}
21impl<'a> ContextView<'a> {
22    pub const fn encoded_bytes(self) -> &'a [u8] {
23        self.encoded
24    }
25    pub const fn parameters(self) -> ContextParameters {
26        self.parameters
27    }
28    pub const fn source(self) -> SourceCommit {
29        self.source
30    }
31    pub const fn entry_count(self) -> usize {
32        self.entries
33    }
34    pub const fn page_refs(self) -> PageRefsView<'a> {
35        self.pages
36    }
37}
38pub struct BodyInput<'a> {
39    pub context_id: StrongDigest,
40    pub context_root: &'a [u8],
41    pub generation: u64,
42    pub predecessor: Option<StrongDigest>,
43    pub entries: usize,
44    pub pages: &'a [PageRef],
45}
46#[derive(Clone, Copy)]
47pub struct BodyView<'a> {
48    pub(crate) encoded: &'a [u8],
49    pub(crate) context_id: StrongDigest,
50    pub(crate) context: ContextView<'a>,
51    pub(crate) pages: PageRefsView<'a>,
52}
53impl<'a> BodyView<'a> {
54    pub const fn encoded_bytes(self) -> &'a [u8] {
55        self.encoded
56    }
57    pub const fn context_id(self) -> StrongDigest {
58        self.context_id
59    }
60    pub const fn context(self) -> ContextView<'a> {
61        self.context
62    }
63    pub const fn page_refs(self) -> PageRefsView<'a> {
64        self.pages
65    }
66}
67fn optional(w: &mut W<'_>, value: Option<StrongDigest>) -> Result<(), E> {
68    match value {
69        Some(d) => w.bytes(d.as_bytes()),
70        None => w.null(),
71    }
72}
73fn source_write(w: &mut W<'_>, s: SourceCommit) -> Result<(), E> {
74    s.validate()?;
75    w.map(8)?;
76    w.uint(0)?;
77    w.uint(s.length)?;
78    w.uint(1)?;
79    w.uint(s.version as u64)?;
80    w.uint(2)?;
81    w.uint(s.flags as u64)?;
82    w.uint(3)?;
83    w.bytes(s.header_digest.as_bytes())?;
84    w.uint(4)?;
85    w.uint(s.index_offset)?;
86    w.uint(5)?;
87    w.uint(s.index_length)?;
88    w.uint(6)?;
89    w.bytes(s.index_digest.as_bytes())?;
90    w.uint(7)?;
91    w.bytes(s.source_digest.as_bytes())
92}
93fn source_read(r: &mut R<'_>) -> Result<SourceCommit, E> {
94    r.map(8)?;
95    r.key(0)?;
96    let length = r.uint()?;
97    r.key(1)?;
98    let version = u16::try_from(r.uint()?).map_err(|_| E::Unsupported)?;
99    r.key(2)?;
100    let flags = u16::try_from(r.uint()?).map_err(|_| E::Unsupported)?;
101    r.key(3)?;
102    let header_digest = r.digest()?;
103    r.key(4)?;
104    let index_offset = r.uint()?;
105    r.key(5)?;
106    let index_length = r.uint()?;
107    r.key(6)?;
108    let index_digest = r.digest()?;
109    r.key(7)?;
110    let source_digest = r.digest()?;
111    let s = SourceCommit {
112        length,
113        version,
114        flags,
115        header_digest,
116        index_offset,
117        index_length,
118        index_digest,
119        source_digest,
120    };
121    s.validate()?;
122    Ok(s)
123}
124fn context_write(w: &mut W<'_>, c: &ContextInput<'_>) -> Result<(), E> {
125    c.parameters.validate()?;
126    if c.entries > MAX_ENTRIES {
127        return Err(E::Limit);
128    }
129    w.profile(13)?;
130    w.uint(2)?;
131    w.bytes(&c.parameters.nonce)?;
132    w.uint(3)?;
133    w.uint(c.parameters.generation)?;
134    w.uint(4)?;
135    optional(w, c.parameters.predecessor)?;
136    w.uint(5)?;
137    source_write(w, c.source)?;
138    w.uint(6)?;
139    w.uint(LEAF_BYTES)?;
140    w.uint(7)?;
141    w.uint(c.entries as u64)?;
142    w.uint(8)?;
143    write_refs(w, c.pages, c.entries)?;
144    w.uint(9)?;
145    w.uint(0)?;
146    w.uint(10)?;
147    w.bytes(c.parameters.semantic_contract.as_bytes())?;
148    w.uint(11)?;
149    w.bytes(c.parameters.policy.as_bytes())?;
150    w.uint(12)?;
151    w.bytes(c.parameters.consumer_profile.as_bytes())
152}
153pub fn encode_context_into(input: &ContextInput<'_>, out: &mut [u8]) -> Result<usize, E> {
154    encode(out, |w| context_write(w, input))
155}
156pub fn decode_context(bytes: &[u8]) -> Result<ContextView<'_>, E> {
157    let mut r = R::new(bytes)?;
158    r.profile(13)?;
159    r.key(2)?;
160    let nonce = r.bytes()?.try_into().map_err(|_| E::Length)?;
161    r.key(3)?;
162    let generation = r.uint()?;
163    r.key(4)?;
164    let predecessor = r.optional_digest()?;
165    r.key(5)?;
166    let source = source_read(&mut r)?;
167    r.key(6)?;
168    if r.uint()? != LEAF_BYTES {
169        return Err(E::Unsupported);
170    }
171    r.key(7)?;
172    let entries = usize::try_from(r.uint()?).map_err(|_| E::Limit)?;
173    if entries > MAX_ENTRIES {
174        return Err(E::Limit);
175    }
176    r.key(8)?;
177    let pages = read_refs(&mut r, entries)?;
178    r.key(9)?;
179    r.zero()?;
180    r.key(10)?;
181    let semantic_contract = r.digest()?;
182    r.key(11)?;
183    let policy = r.digest()?;
184    r.key(12)?;
185    let consumer_profile = r.digest()?;
186    let parameters = ContextParameters {
187        nonce,
188        generation,
189        predecessor,
190        semantic_contract,
191        policy,
192        consumer_profile,
193    };
194    parameters.validate()?;
195    r.finish()?;
196    Ok(ContextView {
197        encoded: bytes,
198        parameters,
199        source,
200        entries,
201        pages,
202    })
203}
204fn body_write(w: &mut W<'_>, b: &BodyInput<'_>) -> Result<(), E> {
205    let c = decode_context(b.context_root)?;
206    if b.generation != c.parameters.generation
207        || b.predecessor != c.parameters.predecessor
208        || b.entries != c.entries
209    {
210        return Err(E::Context);
211    }
212    w.profile(8)?;
213    w.uint(2)?;
214    w.bytes(b.context_id.as_bytes())?;
215    w.uint(3)?;
216    w.bytes(b.context_root)?;
217    w.uint(4)?;
218    w.uint(b.generation)?;
219    w.uint(5)?;
220    optional(w, b.predecessor)?;
221    w.uint(6)?;
222    w.uint(b.entries as u64)?;
223    w.uint(7)?;
224    write_refs(w, b.pages, b.entries)
225}
226pub fn encode_body_into(input: &BodyInput<'_>, out: &mut [u8]) -> Result<usize, E> {
227    encode(out, |w| body_write(w, input))
228}
229pub fn decode_body(bytes: &[u8]) -> Result<BodyView<'_>, E> {
230    let mut r = R::new(bytes)?;
231    r.profile(8)?;
232    r.key(2)?;
233    let context_id = r.digest()?;
234    r.key(3)?;
235    let context = decode_context(r.bytes()?)?;
236    r.key(4)?;
237    let generation = r.uint()?;
238    r.key(5)?;
239    let predecessor = r.optional_digest()?;
240    r.key(6)?;
241    let entries = usize::try_from(r.uint()?).map_err(|_| E::Limit)?;
242    if entries != context.entries
243        || generation != context.parameters.generation
244        || predecessor != context.parameters.predecessor
245    {
246        return Err(E::Context);
247    }
248    r.key(7)?;
249    let pages = read_refs(&mut r, entries)?;
250    r.finish()?;
251    Ok(BodyView {
252        encoded: bytes,
253        context_id,
254        context,
255        pages,
256    })
257}
258
259pub fn context_encoded_len(input: &ContextInput<'_>) -> Result<usize, E> {
260    let mut w = W::measure();
261    context_write(&mut w, input)?;
262    Ok(w.pos)
263}
264pub fn body_encoded_len(input: &BodyInput<'_>) -> Result<usize, E> {
265    let mut w = W::measure();
266    body_write(&mut w, input)?;
267    Ok(w.pos)
268}
269
270impl core::fmt::Debug for ContextView<'_> {
271    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
272        f.debug_struct("ContextView")
273            .field("entries", &self.entries)
274            .field("generation", &self.parameters.generation)
275            .finish_non_exhaustive()
276    }
277}
278impl core::fmt::Debug for BodyView<'_> {
279    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
280        f.debug_struct("BodyView")
281            .field("context_id", &self.context_id)
282            .field("entries", &self.context.entries)
283            .finish_non_exhaustive()
284    }
285}