Skip to main content

qualia_core_db/net/qdnf/evidence/
holds.rs

1//! Overlapping preservation holds (E19.3).
2//!
3//! Release of one hold does not drop others. Expired-hold GC runs through the
4//! same durable [`EvidenceStore`] owner. Live overlapping holds survive GC of
5//! an expired sibling.
6
7use crate::net::qdnf::errors::QdnfError;
8use crate::net::qdnf::types::StrongDigest;
9
10use super::promote::{admit_clock, EvidenceStore, HoldSlot, MAX_HOLDS};
11
12/// Place a live hold. Duplicate `id` is Conflict.
13pub fn place_hold(
14    store: &mut EvidenceStore,
15    id: StrongDigest,
16    evidence: StrongDigest,
17    owner: StrongDigest,
18    deadline: u64,
19    now: u64,
20) -> Result<(), QdnfError> {
21    admit_clock(store, now)?;
22    if id.is_zero() || evidence.is_zero() || owner.is_zero() {
23        return Err(QdnfError::Malformed);
24    }
25    if deadline <= now {
26        return Err(QdnfError::Expired);
27    }
28    if store.find(evidence).is_none() {
29        return Err(QdnfError::Incomplete);
30    }
31    let mut i = 0usize;
32    while i < MAX_HOLDS {
33        if store.holds[i].occupied && store.holds[i].id == id {
34            return Err(QdnfError::Conflict);
35        }
36        i += 1;
37    }
38    let mut free = None;
39    i = 0;
40    while i < MAX_HOLDS {
41        if !store.holds[i].occupied {
42            free = Some(i);
43            break;
44        }
45        i += 1;
46    }
47    let idx = free.ok_or(QdnfError::Capacity)?;
48    store.holds[idx] = HoldSlot {
49        occupied: true,
50        id,
51        evidence,
52        owner,
53        deadline,
54        live: true,
55    };
56    Ok(())
57}
58
59/// Authenticated release of one hold. Other live holds on the same evidence remain.
60pub fn release_hold(
61    store: &mut EvidenceStore,
62    id: StrongDigest,
63    owner: StrongDigest,
64    now: u64,
65) -> Result<(), QdnfError> {
66    admit_clock(store, now)?;
67    let mut i = 0usize;
68    while i < MAX_HOLDS {
69        if store.holds[i].occupied && store.holds[i].id == id {
70            if store.holds[i].owner != owner {
71                return Err(QdnfError::Unauthorized);
72            }
73            if !store.holds[i].live {
74                return Err(QdnfError::DoubleRelease);
75            }
76            store.holds[i].live = false;
77            return Ok(());
78        }
79        i += 1;
80    }
81    Err(QdnfError::Incomplete)
82}
83
84/// GC expired holds for `owner` only. Live holds and other owners are untouched.
85pub fn gc_expired(
86    store: &mut EvidenceStore,
87    owner: StrongDigest,
88    now: u64,
89) -> Result<usize, QdnfError> {
90    admit_clock(store, now)?;
91    if owner.is_zero() {
92        return Err(QdnfError::Malformed);
93    }
94    let mut dropped = 0usize;
95    let mut i = 0usize;
96    while i < MAX_HOLDS {
97        if store.holds[i].occupied
98            && store.holds[i].owner == owner
99            && store.holds[i].deadline <= now
100        {
101            store.holds[i] = HoldSlot::EMPTY;
102            dropped += 1;
103        }
104        i += 1;
105    }
106    Ok(dropped)
107}
108
109/// Count live holds bound to `evidence`.
110pub fn live_hold_count(store: &EvidenceStore, evidence: StrongDigest) -> usize {
111    let mut n = 0usize;
112    let mut i = 0usize;
113    while i < MAX_HOLDS {
114        if store.holds[i].occupied && store.holds[i].live && store.holds[i].evidence == evidence {
115            n += 1;
116        }
117        i += 1;
118    }
119    n
120}
121
122#[cfg(test)]
123mod tests {
124    use super::*;
125    use crate::crypto::network::digest::sha384;
126    use crate::net::qdnf::authority::ObservationQuality;
127    use crate::net::qdnf::evidence::classes::{classify, EvidenceClass};
128    use crate::net::qdnf::evidence::promote::{
129        promote, AuthorityAtTime, CustodyBind, EvidenceStore, MAX_ORIGINAL,
130    };
131    use crate::net::qdnf::policy_labels::{
132        encode_label_into, verify_label, Confidentiality, LabelFields,
133    };
134    use crate::net::qdnf::types::Generation;
135    use crate::wal_intent::{IntentTable, TxId};
136    use std::sync::{Arc, Mutex};
137    use std::thread;
138
139    fn tx(n: u8) -> TxId {
140        let mut bytes = [0u8; 16];
141        bytes[15] = n;
142        TxId { bytes }
143    }
144
145    fn labelled() -> crate::net::qdnf::evidence::classes::ClassifiedEvidence {
146        let issuer = sha384(b"e19-issuer");
147        let mut fields = LabelFields::request(Confidentiality::C1Private, issuer);
148        fields.purpose_count = 1;
149        fields.purposes[0] = sha384(b"purpose");
150        let mut buf = [0u8; 256];
151        let n = encode_label_into(&fields, &mut buf).unwrap();
152        let v = verify_label(fields, &buf[..n]).unwrap();
153        classify(EvidenceClass::BoundedOperational, &v).unwrap()
154    }
155
156    fn seed(store: &mut EvidenceStore, intents: &mut IntentTable, now: u64) -> StrongDigest {
157        let mut out = [0u8; MAX_ORIGINAL];
158        let rec = promote(
159            store,
160            intents,
161            tx(1),
162            labelled(),
163            b"held-bytes",
164            AuthorityAtTime {
165                writer_id: 3,
166                generation: Generation(1),
167                unix_secs: now,
168            },
169            1,
170            ObservationQuality::Measured,
171            CustodyBind {
172                from: sha384(b"from"),
173                to: sha384(b"to"),
174            },
175            None,
176            now + 1_000,
177            now,
178            &mut out,
179        )
180        .unwrap();
181        rec.original_digest
182    }
183
184    #[test]
185    fn release_one_hold_does_not_drop_others() {
186        let mut store = EvidenceStore::new();
187        let mut intents = IntentTable::new();
188        let ev = seed(&mut store, &mut intents, 100);
189        let owner = sha384(b"owner");
190        place_hold(&mut store, sha384(b"h1"), ev, owner, 500, 110).unwrap();
191        place_hold(&mut store, sha384(b"h2"), ev, owner, 500, 120).unwrap();
192        assert_eq!(live_hold_count(&store, ev), 2);
193        release_hold(&mut store, sha384(b"h1"), owner, 130).unwrap();
194        assert_eq!(live_hold_count(&store, ev), 1);
195        assert_eq!(store.count(), 1);
196    }
197
198    #[test]
199    fn gc_expired_same_owner_leaves_live_overlap() {
200        let mut store = EvidenceStore::new();
201        let mut intents = IntentTable::new();
202        let ev = seed(&mut store, &mut intents, 100);
203        let owner = sha384(b"owner");
204        place_hold(&mut store, sha384(b"short"), ev, owner, 150, 110).unwrap();
205        place_hold(&mut store, sha384(b"long"), ev, owner, 800, 120).unwrap();
206        let dropped = gc_expired(&mut store, owner, 200).unwrap();
207        assert_eq!(dropped, 1);
208        assert_eq!(live_hold_count(&store, ev), 1);
209    }
210
211    #[test]
212    fn hold_gc_race_overlapping_holds_survive() {
213        let mut store = EvidenceStore::new();
214        let mut intents = IntentTable::new();
215        let ev = seed(&mut store, &mut intents, 100);
216        let owner = sha384(b"owner");
217        place_hold(&mut store, sha384(b"a"), ev, owner, 160, 110).unwrap();
218        place_hold(&mut store, sha384(b"b"), ev, owner, 900, 120).unwrap();
219        let store = Arc::new(Mutex::new(store));
220        let left = {
221            let store = Arc::clone(&store);
222            thread::spawn(move || {
223                release_hold(&mut store.lock().unwrap(), sha384(b"a"), owner, 180)
224            })
225        };
226        let right = {
227            let store = Arc::clone(&store);
228            thread::spawn(move || gc_expired(&mut store.lock().unwrap(), owner, 180))
229        };
230        let _ = left.join().unwrap();
231        let _ = right.join().unwrap();
232        assert_eq!(live_hold_count(&store.lock().unwrap(), ev), 1);
233        assert_eq!(store.lock().unwrap().count(), 1);
234    }
235
236    #[test]
237    fn other_owner_gc_cannot_drop_hold() {
238        let mut store = EvidenceStore::new();
239        let mut intents = IntentTable::new();
240        let ev = seed(&mut store, &mut intents, 100);
241        place_hold(&mut store, sha384(b"h"), ev, sha384(b"owner-a"), 150, 110).unwrap();
242        assert_eq!(gc_expired(&mut store, sha384(b"owner-b"), 200).unwrap(), 0);
243        assert_eq!(live_hold_count(&store, ev), 1);
244    }
245}