qualia_core_db/net/qdnf/evidence/
holds.rs1use crate::net::qdnf::errors::QdnfError;
8use crate::net::qdnf::types::StrongDigest;
9
10use super::promote::{admit_clock, EvidenceStore, HoldSlot, MAX_HOLDS};
11
12pub 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
59pub 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
84pub 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
109pub 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}