qualia_core_db/bundle/stream/storage/
checkpoint.rs1use super::bitmap::{geometry, validate_tail};
3use super::wire::*;
4use super::{
5 BITMAP_BYTES, CandidateBitmapPage, IDENTITY_BYTES, ResumeHint, StorageError as E,
6 StorageIdentity, decode_identity, encode_identity,
7};
8use crate::crypto::network::digest::sha384;
9use crate::net::qdnf::types::StrongDigest;
10pub const CHECKPOINT_BYTES: usize = 400;
11const MAGIC: &[u8; 8] = b"QBSCP01\0";
12#[derive(Clone, Copy, Debug)]
14pub struct UntrustedCheckpoint {
15 identity: StorageIdentity,
16 page: u64,
17 sequence: u64,
18 payload_digest: StrongDigest,
19}
20impl UntrustedCheckpoint {
21 pub const fn identity(&self) -> &StorageIdentity {
22 &self.identity
23 }
24 pub const fn page_number(&self) -> u64 {
25 self.page
26 }
27 pub const fn sequence(&self) -> u64 {
28 self.sequence
29 }
30 pub fn bind_payload<'a>(
31 &self,
32 expected: &StorageIdentity,
33 expected_page: u64,
34 payload: &'a [u8; BITMAP_BYTES],
35 ) -> Result<ResumeHint<'a>, E> {
36 if self.identity != *expected {
37 return Err(E::IdentityMismatch);
38 }
39 if self.page != expected_page {
40 return Err(E::PageMismatch);
41 }
42 let (_, valid) = geometry(expected, expected_page)?;
43 if sha384(payload) != self.payload_digest {
44 return Err(E::DigestMismatch);
45 }
46 validate_tail(payload, valid)?;
47 Ok(ResumeHint {
48 identity: self.identity,
49 page: self.page,
50 sequence: self.sequence,
51 payload,
52 })
53 }
54}
55pub fn encode_checkpoint(
56 page: &CandidateBitmapPage<'_>,
57 sequence: u64,
58 out: &mut [u8],
59) -> Result<usize, E> {
60 let out = out.get_mut(..CHECKPOINT_BYTES).ok_or(E::Capacity)?;
61 out.fill(0);
62 out[..8].copy_from_slice(MAGIC);
63 out[8..10].copy_from_slice(&1u16.to_be_bytes());
64 encode_identity(page.identity(), &mut out[16..16 + IDENTITY_BYTES])?;
65 out[272..280].copy_from_slice(&page.page_number().to_be_bytes());
66 out[280..284].copy_from_slice(&(BITMAP_BYTES as u32).to_be_bytes());
67 out[288..336].copy_from_slice(sha384(page.payload()).as_bytes());
68 out[336..344].copy_from_slice(&sequence.to_be_bytes());
69 let digest = sha384(&out[..352]);
70 out[352..400].copy_from_slice(digest.as_bytes());
71 Ok(CHECKPOINT_BYTES)
72}
73pub fn decode_checkpoint(bytes: &[u8]) -> Result<UntrustedCheckpoint, E> {
74 if bytes.len() != CHECKPOINT_BYTES {
75 return Err(E::Length);
76 }
77 if &bytes[..8] != MAGIC {
78 return Err(E::Magic);
79 }
80 if u16_at(bytes, 8)? != 1 {
81 return Err(E::Version);
82 }
83 if u16_at(bytes, 10)? != 0 {
84 return Err(E::Flags);
85 }
86 zero(&bytes[12..16])?;
87 zero(&bytes[284..288])?;
88 zero(&bytes[344..352])?;
89 if u32_at(bytes, 280)? != BITMAP_BYTES as u32 {
90 return Err(E::Length);
91 }
92 if sha384(&bytes[..352]) != digest_at(bytes, 352)? {
93 return Err(E::DigestMismatch);
94 }
95 let identity = decode_identity(&bytes[16..272])?;
96 let page = u64_at(bytes, 272)?;
97 geometry(&identity, page)?;
98 Ok(UntrustedCheckpoint {
99 identity,
100 page,
101 sequence: u64_at(bytes, 336)?,
102 payload_digest: digest_at(bytes, 288)?,
103 })
104}