qualia_core_db/bundle/stream/descriptor/
roots.rs1use 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}