1use super::{
6 FallbackPolicy, HttpObject, HttpProvider, InclusiveRange, ProviderError, ServeOptions, Served,
7 Validator,
8};
9use crate::audio::qac::{QacStorageOptions, QacStorageView};
10use crate::bundle::stream::formats::{
11 emf_present_id, p64_present_id, qac_present_id, AuthenticatedRange, EmfStreamView,
12 P64StreamView, Q42AuthenticatedRangeSource, QacStreamView,
13};
14use crate::bundle::stream::plan::{
15 evaluate, EntryFamily, Inventory, Obligation, PlanError, PrincipalSelection, Readiness,
16 RecordUnit, Region, Schedule, ScheduledUnit, WorkClass, MAX_PLAN_ENTRIES, MAX_SCHEDULE_ITEMS,
17};
18use crate::bundle::stream::policy::{LocalEffectControl, LocalWholeSourceGrant};
19use crate::bundle::stream::proof::{
20 OutboardNode, SpanLimits, VerifiedLeafSpan, LEAF_BYTES, MAX_SIBLINGS,
21};
22use crate::bundle::stream::proof::verify_leaf_span;
23use crate::bundle::stream::selection::SelectedPlainEntry;
24use crate::crypto::network::authority::PinAuthority;
25use crate::net::peer::replication::qbdl::provider::{OutboardCatalog, OutboardLimits};
26use crate::net::peer::runtime::ReservationLedger;
27use crate::net::qdnf::types::StrongDigest;
28use crate::q42::field_envelope::{Family, Limits, StructuralView};
29
30pub struct BoundHttpEntry<'src, 'sel, 'nodes, 'meta> {
32 pub entry_id: u32,
33 pub provider: HttpProvider<'src, 'sel, 'nodes, 'meta>,
34}
35
36#[derive(Clone, Copy)]
38pub struct ServedObject {
39 pub entry_id: u32,
40 pub family: EntryFamily,
41 pub status: u16,
42 pub body_off: usize,
43 pub body_len: usize,
44 pub total: u64,
45 pub etag: [u8; 98],
46 pub etag_len: usize,
47}
48
49pub struct HttpMuxReport {
51 pub transferred: u16,
52 pub control: u16,
53 pub delayed_deferred: u16,
54 pub cancelled_skipped: u16,
55 pub shared_reused: u16,
56 pub order: [Option<EntryFamily>; MAX_SCHEDULE_ITEMS],
57 pub order_len: u16,
58 pub objects: [Option<ServedObject>; MAX_SCHEDULE_ITEMS],
59 pub objects_len: u16,
60}
61
62pub struct HttpMux {
64 schedule: Schedule,
65 blocked: Option<ProviderError>,
66 shared_reused: u16,
67 cancelled_skipped: u16,
68 deferred_pending: u16,
69 deferred_ids: [u32; MAX_PLAN_ENTRIES],
70 deferred_len: usize,
71}
72
73fn map_plan(e: PlanError) -> ProviderError {
74 match e {
75 PlanError::Capacity | PlanError::Limit => ProviderError::Capacity,
76 PlanError::DuplicateId | PlanError::Identity | PlanError::Cycle | PlanError::Graph => {
77 ProviderError::Identity
78 }
79 PlanError::Field | PlanError::Unsupported => ProviderError::Unsupported,
80 PlanError::Refused => ProviderError::Policy,
81 }
82}
83
84fn deferred_family(family: Option<EntryFamily>) -> bool {
85 matches!(family, Some(EntryFamily::M64 | EntryFamily::P64))
86}
87
88pub fn entry_slice<'a>(
90 source: &'a [u8],
91 selected: SelectedPlainEntry<'_>,
92) -> Result<&'a [u8], ProviderError> {
93 let start = usize::try_from(selected.offset()).map_err(|_| ProviderError::Bounds)?;
94 let len = usize::try_from(selected.logical_length()).map_err(|_| ProviderError::Bounds)?;
95 let end = start.checked_add(len).ok_or(ProviderError::Bounds)?;
96 if end > source.len() {
97 return Err(ProviderError::Identity);
98 }
99 Ok(&source[start..end])
100}
101
102fn whole_span<'a>(
103 selected: SelectedPlainEntry<'a>,
104 bytes: &'a [u8],
105 siblings: &'a mut [StrongDigest],
106) -> Result<VerifiedLeafSpan<'a>, ProviderError> {
107 if selected.logical_length() != bytes.len() as u64 {
108 return Err(ProviderError::Identity);
109 }
110 let spec = selected.tree_spec().map_err(|_| ProviderError::Identity)?;
111 verify_leaf_span(
112 &spec,
113 selected.root(),
114 0,
115 bytes,
116 &[&[0]],
117 siblings,
118 SpanLimits {
119 max_leaves: 1,
120 max_encoded_bytes: LEAF_BYTES as usize,
121 },
122 )
123 .map_err(|_| ProviderError::Proof)
124}
125
126pub fn entry_admits_family(
128 source: &[u8],
129 selected: SelectedPlainEntry<'_>,
130 family: EntryFamily,
131) -> bool {
132 let Ok(bytes) = entry_slice(source, selected) else {
133 return false;
134 };
135 if selected.logical_length() != bytes.len() as u64 {
136 return false;
137 }
138 match family {
139 EntryFamily::Qac => {
140 let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
141 if let Ok(span) = whole_span(selected, bytes, &mut siblings) {
142 if let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) {
143 if let Ok(view) = QacStreamView::admit(range, QacStorageOptions::default()) {
144 return qac_present_id(selected.entry_id(), &view).is_some();
145 }
146 }
147 }
148 QacStorageView::open(bytes, QacStorageOptions::default()).is_ok()
149 }
150 EntryFamily::Emf => {
151 let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
152 if let Ok(span) = whole_span(selected, bytes, &mut siblings) {
153 if let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) {
154 if let Ok(view) = EmfStreamView::admit(range, Limits::default()) {
155 return emf_present_id(selected.entry_id(), &view).is_some();
156 }
157 }
158 }
159 StructuralView::open(bytes, Family::EmfV4Candidate, Limits::default()).is_ok()
160 }
161 EntryFamily::Q42 => {
162 let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
163 let Ok(span) = whole_span(selected, bytes, &mut siblings) else {
164 return false;
165 };
166 let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) else {
167 return false;
168 };
169 Q42AuthenticatedRangeSource::new(selected, &[range], bytes.len() as u64, 1).is_ok()
170 }
171 EntryFamily::Opaque => false,
172 EntryFamily::P64 => {
173 let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
174 if let Ok(span) = whole_span(selected, bytes, &mut siblings) {
175 if let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) {
176 if let Ok(view) = P64StreamView::admit(range) {
177 return p64_present_id(selected.entry_id(), &view).is_some();
178 }
179 }
180 }
181 false
182 }
183 EntryFamily::TenD | EntryFamily::M64 => true,
184 }
185}
186
187pub fn bind_http_entry<'src, 'sel, 'nodes, 'meta>(
189 source: &'src [u8],
190 selected: SelectedPlainEntry<'sel>,
191 nodes: &'nodes [OutboardNode],
192 root: StrongDigest,
193 descriptor: &'meta [u8],
194 entry_page: &'meta [u8],
195) -> Result<BoundHttpEntry<'src, 'sel, 'nodes, 'meta>, ProviderError> {
196 let spec = selected.tree_spec().map_err(|_| ProviderError::Identity)?;
197 let catalog = OutboardCatalog::new(
198 selected,
199 spec,
200 root,
201 nodes,
202 OutboardLimits {
203 max_nodes: nodes.len(),
204 max_bytes: nodes.len() * core::mem::size_of::<OutboardNode>(),
205 },
206 )?;
207 Ok(BoundHttpEntry {
208 entry_id: selected.entry_id(),
209 provider: HttpProvider::bind(source, catalog, descriptor, entry_page)?,
210 })
211}
212
213impl HttpMux {
214 pub fn compile(
215 inventory: &Inventory<'_>,
216 selections: &[PrincipalSelection<'_>],
217 present: &[u32],
218 ) -> Result<Self, ProviderError> {
219 let (blocked, shared_reused, deferred_ids, deferred_len) =
220 inspect(inventory, selections, present);
221 let schedule = Schedule::compile(inventory, selections, present).map_err(map_plan)?;
222 Ok(Self {
223 schedule,
224 blocked,
225 shared_reused,
226 cancelled_skipped: 0,
227 deferred_pending: deferred_len as u16,
228 deferred_ids,
229 deferred_len,
230 })
231 }
232
233 pub fn next_unit(&mut self) -> Option<ScheduledUnit> {
234 self.schedule.next()
235 }
236
237 pub fn acknowledge(&mut self, unit: ScheduledUnit) -> Result<(), ProviderError> {
238 self.schedule
239 .acknowledge_complete(unit.principal(), unit.entry_id(), unit.unit().leaf())
240 .map_err(map_plan)
241 }
242
243 pub fn acknowledge_complete(
244 &mut self,
245 principal: u64,
246 entry_id: Option<u32>,
247 leaf: u64,
248 ) -> Result<(), ProviderError> {
249 self.schedule
250 .acknowledge_complete(principal, entry_id, leaf)
251 .map_err(map_plan)
252 }
253
254 pub fn cancel(&mut self, entry_id: u32, region: Option<Region>) -> usize {
255 let n = self.schedule.cancel(entry_id, region);
256 if n > 0 {
257 self.cancelled_skipped = self.cancelled_skipped.saturating_add(n as u16);
258 if self.is_deferred_id(entry_id) {
259 self.deferred_pending = self.deferred_pending.saturating_sub(1);
260 }
261 }
262 n
263 }
264
265 pub fn occupancy_retained(&self, principal: u64, entry_id: Option<u32>, leaf: u64) -> bool {
266 self.schedule.occupancy_retained(principal, entry_id, leaf)
267 }
268
269 pub fn push_control(&mut self, principal: u64, unit: RecordUnit) -> Result<(), ProviderError> {
270 self.schedule.push_control(principal, unit).map_err(map_plan)
271 }
272
273 pub fn is_charged(&self, entry_id: u32) -> bool {
274 self.schedule.is_charged(self.schedule.candidate(), entry_id)
275 }
276
277 pub const fn cancelled_skipped(&self) -> u16 {
278 self.cancelled_skipped
279 }
280
281 pub const fn shared_reused(&self) -> u16 {
282 self.shared_reused
283 }
284
285 pub const fn len(&self) -> usize {
286 self.schedule.len()
287 }
288
289 fn is_deferred_id(&self, entry_id: u32) -> bool {
290 self.deferred_ids[..self.deferred_len]
291 .iter()
292 .any(|id| *id == entry_id)
293 }
294}
295
296pub fn serve_scheduled(
300 mux: &mut HttpMux,
301 entries: &[BoundHttpEntry<'_, '_, '_, '_>],
302 grant: &mut LocalWholeSourceGrant<'_, '_>,
303 pins: &PinAuthority,
304 clock: impl Fn() -> u64,
305 ledger: &mut ReservationLedger,
306 out: &mut [u8],
307) -> Result<HttpMuxReport, ProviderError> {
308 if let Some(e) = mux.blocked {
309 return Err(e);
310 }
311 match grant.accept_local_scoped(pins, clock, |authority| {
312 Ok(drive_scheduled(mux, entries, authority, ledger, out))
313 }) {
314 Ok(inner) => inner,
315 Err(_) => Err(ProviderError::Policy),
316 }
317}
318
319fn drive_scheduled(
320 mux: &mut HttpMux,
321 entries: &[BoundHttpEntry<'_, '_, '_, '_>],
322 authority: &mut LocalEffectControl<'_, '_>,
323 ledger: &mut ReservationLedger,
324 out: &mut [u8],
325) -> Result<HttpMuxReport, ProviderError> {
326 let mut report = HttpMuxReport {
327 transferred: 0,
328 control: 0,
329 delayed_deferred: 0,
330 cancelled_skipped: mux.cancelled_skipped,
331 shared_reused: mux.shared_reused,
332 order: [None; MAX_SCHEDULE_ITEMS],
333 order_len: 0,
334 objects: [None; MAX_SCHEDULE_ITEMS],
335 objects_len: 0,
336 };
337 let mut sent = [None; MAX_SCHEDULE_ITEMS];
338 let mut sent_len = 0usize;
339 let mut cursor = 0usize;
340 while let Some(unit) = mux.next_unit() {
341 push_order(&mut report, unit.family());
342 if unit.entry_id().is_none() || unit.class() == WorkClass::Control {
343 if mux.deferred_pending > 0 {
344 report.delayed_deferred = report.delayed_deferred.saturating_add(1);
345 }
346 mux.acknowledge(unit)?;
347 report.control = report.control.saturating_add(1);
348 continue;
349 }
350 let id = match unit.entry_id() {
351 Some(id) => id,
352 None => return Err(ProviderError::Identity),
353 };
354 let family = match unit.family() {
355 Some(f) => f,
356 None => return Err(ProviderError::Identity),
357 };
358 let leaf = unit.unit().leaf();
359 if sent[..sent_len].iter().any(|slot| *slot == Some((id, leaf))) {
360 report.shared_reused = report.shared_reused.saturating_add(1);
361 mux.acknowledge(unit)?;
362 continue;
363 }
364 let idx = match entries.iter().position(|e| e.entry_id == id) {
365 Some(i) => i,
366 None => return Err(ProviderError::Identity),
367 };
368 let deferred = deferred_family(unit.family());
369 if !deferred && mux.deferred_pending > 0 {
370 report.delayed_deferred = report.delayed_deferred.saturating_add(1);
371 }
372 let provider = &entries[idx].provider;
373 let total = provider.selected().logical_length();
374 let range = InclusiveRange::from_start_length(0, total)?;
375 let mut etag = [0u8; 98];
376 let etag_len = provider.representation_etag(&mut etag)?;
377 let served: Served = provider.serve(
378 HttpObject::Representation,
379 Some(range),
380 Some(&etag[..etag_len]),
381 Validator {
382 etag: Some(&etag[..etag_len]),
383 last_modified: None,
384 },
385 ServeOptions {
386 fallback: FallbackPolicy::FORBIDDEN,
387 verified_peer: true,
388 },
389 authority,
390 ledger,
391 &mut out[cursor..],
392 )?;
393 if served.status != 200 && served.status != 206 {
394 return Err(ProviderError::Unsatisfiable);
395 }
396 let object = ServedObject {
397 entry_id: id,
398 family,
399 status: served.status,
400 body_off: cursor,
401 body_len: served.body_len,
402 total: served.total,
403 etag: served.headers.etag,
404 etag_len: served.headers.etag_len,
405 };
406 cursor = cursor
407 .checked_add(served.body_len)
408 .ok_or(ProviderError::Capacity)?;
409 if report.objects_len as usize >= MAX_SCHEDULE_ITEMS {
410 return Err(ProviderError::Capacity);
411 }
412 report.objects[report.objects_len as usize] = Some(object);
413 report.objects_len = report.objects_len.saturating_add(1);
414 if sent_len < MAX_SCHEDULE_ITEMS {
415 sent[sent_len] = Some((id, leaf));
416 sent_len += 1;
417 }
418 if deferred {
419 mux.deferred_pending = mux.deferred_pending.saturating_sub(1);
420 }
421 mux.acknowledge(unit)?;
422 report.transferred = report.transferred.saturating_add(1);
423 }
424 Ok(report)
425}
426
427fn push_order(report: &mut HttpMuxReport, family: Option<EntryFamily>) {
428 let i = report.order_len as usize;
429 if i < MAX_SCHEDULE_ITEMS {
430 report.order[i] = family;
431 report.order_len = report.order_len.saturating_add(1);
432 }
433}
434
435fn inspect(
436 inventory: &Inventory<'_>,
437 selections: &[PrincipalSelection<'_>],
438 present: &[u32],
439) -> (
440 Option<ProviderError>,
441 u16,
442 [u32; MAX_PLAN_ENTRIES],
443 usize,
444) {
445 let mut blocked = None;
446 let mut cover = [0u8; MAX_PLAN_ENTRIES];
447 for sel in selections {
448 let mut seen = [false; MAX_PLAN_ENTRIES];
449 for intent in sel.request().intents() {
450 match evaluate(
451 inventory,
452 intent.entry_id(),
453 Some(intent.family()),
454 present,
455 ) {
456 Readiness::Refused | Readiness::Incomplete { .. } => {
457 blocked = Some(ProviderError::Policy);
458 }
459 Readiness::Ready | Readiness::Opaque => {}
460 }
461 walk_ready(
462 inventory,
463 intent.entry_id(),
464 present,
465 &mut seen,
466 &mut cover,
467 );
468 }
469 }
470 let mut shared = 0u16;
471 for c in cover {
472 if c > 1 {
473 shared = shared.saturating_add(u16::from(c - 1));
474 }
475 }
476 let mut deferred_ids = [0u32; MAX_PLAN_ENTRIES];
477 let mut deferred_len = 0usize;
478 for (i, entry) in inventory.entries().iter().enumerate() {
479 if cover[i] == 0 || !deferred_family(Some(entry.family())) {
480 continue;
481 }
482 if deferred_len < MAX_PLAN_ENTRIES {
483 deferred_ids[deferred_len] = entry.entry_id();
484 deferred_len += 1;
485 }
486 }
487 (blocked, shared, deferred_ids, deferred_len)
488}
489
490fn walk_ready(
491 inventory: &Inventory<'_>,
492 start: u32,
493 present: &[u32],
494 seen: &mut [bool; MAX_PLAN_ENTRIES],
495 cover: &mut [u8; MAX_PLAN_ENTRIES],
496) {
497 let mut stack = [0u32; MAX_PLAN_ENTRIES];
498 let mut sp = 0usize;
499 push_id(inventory, &mut stack, &mut sp, seen, start);
500 while sp > 0 {
501 sp -= 1;
502 let id = stack[sp];
503 let Some(entry) = inventory.entry(id) else {
504 continue;
505 };
506 let readiness = evaluate(inventory, id, Some(entry.family()), present);
507 if readiness == Readiness::Ready {
508 if let Some(idx) = inventory.index_of(id) {
509 cover[idx] = cover[idx].saturating_add(1);
510 }
511 }
512 for edge in inventory.edges() {
513 if edge.from_id() != id {
514 continue;
515 }
516 let dep = edge.to_id();
517 let include = match edge.obligation() {
518 Obligation::Mandatory => true,
519 Obligation::Optional => evaluate(inventory, dep, None, present) == Readiness::Ready,
520 };
521 if include {
522 push_id(inventory, &mut stack, &mut sp, seen, dep);
523 }
524 }
525 }
526}
527
528fn push_id(
529 inventory: &Inventory<'_>,
530 stack: &mut [u32; MAX_PLAN_ENTRIES],
531 sp: &mut usize,
532 seen: &mut [bool; MAX_PLAN_ENTRIES],
533 id: u32,
534) {
535 let Some(idx) = inventory.index_of(id) else {
536 return;
537 };
538 if seen[idx] {
539 return;
540 }
541 if *sp >= MAX_PLAN_ENTRIES {
542 return;
543 }
544 seen[idx] = true;
545 stack[*sp] = id;
546 *sp += 1;
547}
548
549#[cfg(all(test, not(target_arch = "wasm32")))]
550mod mixed_http_tests {
551 use super::{
554 bind_http_entry, entry_admits_family, entry_slice, serve_scheduled, whole_span,
555 AuthenticatedRange, BoundHttpEntry, EntryFamily, FallbackPolicy, HttpMux, HttpObject,
556 InclusiveRange, OutboardNode, ProviderError, ReservationLedger, ServeOptions, ServedObject,
557 Validator, LEAF_BYTES, MAX_SIBLINGS,
558 };
559 use crate::bundle::stream::proof::TreeBuilder;
560 use super::super::{
561 get_range, tls_is_pq_publisher_authority, write_content_range, write_strong_etag,
562 FetchBudget, Fetched, LigGate, RangeRequest, HEADER_CAP, LEGACY_FULL_OBJECT_FALLBACK_BYTES,
563 };
564 use crate::bundle::stream::{
565 descriptor::{
566 CandidateIdentity, ContextParameters, EntryRecord, PageRef, HASH_SCRATCH_BYTES,
567 MAX_ENCODED, MAX_METADATA,
568 },
569 index::{admit_header, admit_index, EntryScratch, ExtentLimit, IndexReadLimits},
570 plan::{
571 DependencyEdge, DependencyReason, Inventory, Obligation, PlanEntry, PlanEntrySpec,
572 PrincipalSelection, RecordUnit, RepresentationClass, ResourceEstimate,
573 SelectionIntent, SelectionRequest,
574 },
575 policy::{
576 adopt_local_whole_source, authenticate_closure, encode_manifest_into, BoundClosure,
577 LocalGrantRequest, ManifestFields, PublicationProof, CLOSURE_PURPOSE, MAX_MANIFEST_BYTES,
578 PUBLICATION_PURPOSE,
579 },
580 publish::{EntryAssignment, PlainPublisher, PublicationClass, PublisherOptions},
581 selection::{select_entry, SelectedPlainEntry},
582 };
583 use crate::bundle::{BundleReadLimits, BundleWriter};
584 use crate::crypto::network::{
585 authority::{LocalBootstrap, PinAuthority, PinConfig, PinHandle},
586 cose,
587 digest::sha384,
588 types::{KeyEpoch, KeyPurpose},
589 };
590 use crate::mini_parser::hash_token;
591 use crate::net::peer::runtime::ResourceBudget;
592 use crate::net::qdnf::authority::AuthorityOwner;
593 use crate::net::qdnf::types::{OperationId, StrongDigest};
594 use crate::q42::q42_volume::{
595 validate_exact_range_response, write_unified_volume, Q42ByteRange, Q42RangeSource,
596 Q42RangeVolume,
597 };
598 use crate::semantic_instruments::resolve::{bounded_closure::*, DependencyKind};
599 use crate::NQuin;
600 use crate::bundle::stream::formats::Q42AuthenticatedRangeSource;
601 use ed25519_dalek::SigningKey;
602 use fips204::{
603 ml_dsa_65,
604 traits::{KeyGen, SerDes},
605 };
606 use std::collections::HashMap;
607 use std::io::{Read, Write};
608 use std::net::{TcpListener, TcpStream};
609 use std::sync::{Arc, Mutex};
610 use std::thread;
611 use std::time::Duration;
612 use tempfile::NamedTempFile;
613
614 const QAC_OPAQUE: &[u8] =
615 include_bytes!("../../../q42/field_envelope/fixtures/candidate/qac_candidate-opaque.qac");
616 const QAC_PCM: &[u8] = include_bytes!(
617 "../../../q42/field_envelope/fixtures/candidate/qac_candidate-pcm-signed-zero.qac"
618 );
619 const EMF_OPAQUE: &[u8] =
620 include_bytes!("../../../q42/field_envelope/fixtures/candidate/emf_candidate-opaque.emf");
621 const EMF_ALIGN: &[u8] = include_bytes!(
622 "../../../q42/field_envelope/fixtures/candidate/emf_candidate-aligned4096.emf"
623 );
624 const M64_BYTES: &[u8] = b"m64-delay-payload-not-a-field";
625
626 const ID_QAC_OPAQUE: u32 = 10;
627 const ID_QAC_PCM: u32 = 11;
628 const ID_EMF_OPAQUE: u32 = 20;
629 const ID_EMF_ALIGN: u32 = 21;
630 const ID_M64: u32 = 30;
631 const ID_Q42: u32 = 40;
632 const ID_CALIB: u32 = 60;
633
634 const PATH: &[u8] = b"/objects/mixed/representations/10";
635
636 struct Scene {
637 nodes: [ClosureNode<'static>; 3],
638 edges: [ClosureEdge; 2],
639 fields: ManifestFields,
640 manifest: Vec<u8>,
641 body: Vec<u8>,
642 source: Vec<u8>,
643 entry_page: Vec<u8>,
644 identity: CandidateIdentity,
645 ml_sk: ml_dsa_65::PrivateKey,
646 ml_pk: [u8; 1952],
647 ed_sk: SigningKey,
648 ed_pk: [u8; 32],
649 }
650
651 impl Scene {
652 fn source(&self) -> &[u8] {
653 &self.source
654 }
655 fn body(&self) -> &[u8] {
656 &self.body
657 }
658 fn entry_page(&self) -> &[u8] {
659 &self.entry_page
660 }
661 fn identity(&self) -> CandidateIdentity {
662 self.identity
663 }
664 fn publish(files: &[(&str, &str, &[u8], u32)]) -> Self {
665 let nodes = [
666 ClosureNode {
667 digest: sha384(b"root"),
668 kind: DependencyKind::Instrument,
669 original_bytes: b"root",
670 },
671 ClosureNode {
672 digest: sha384(b"policy"),
673 kind: DependencyKind::LawPackage,
674 original_bytes: b"policy",
675 },
676 ClosureNode {
677 digest: sha384(b"consumer"),
678 kind: DependencyKind::NativeModule,
679 original_bytes: b"consumer",
680 },
681 ];
682 let edges = [
683 ClosureEdge {
684 dependent: nodes[0].digest,
685 dependency: nodes[1].digest,
686 },
687 ClosureEdge {
688 dependent: nodes[0].digest,
689 dependency: nodes[2].digest,
690 },
691 ];
692 let mut writer = BundleWriter::new();
693 for (key, kind, bytes, _) in files {
694 writer
695 .add_file(*key, *kind, bytes.to_vec(), None)
696 .unwrap();
697 }
698 let source = writer.build().unwrap();
699 let fields = ManifestFields {
700 source: sha384(&source),
701 source_length: source.len() as u64,
702 semantic_root: nodes[0].digest,
703 policy: nodes[1].digest,
704 consumer: nodes[2].digest,
705 issuer: StrongDigest([31; 48]),
706 };
707 let candidate = verify_closure(nodes[0].digest, &nodes, &edges).unwrap();
708 let mut manifest = vec![0; MAX_MANIFEST_BYTES];
709 let n = encode_manifest_into(fields, &candidate, &mut manifest).unwrap();
710 manifest.truncate(n);
711 let parameters = ContextParameters {
712 nonce: [1; 32],
713 generation: 0,
714 predecessor: None,
715 semantic_contract: sha384(&manifest),
716 policy: fields.policy,
717 consumer_profile: fields.consumer,
718 };
719 let assignments: Vec<EntryAssignment> = files
720 .iter()
721 .map(|(_, _, _, id)| EntryAssignment {
722 id: *id,
723 inner_version: 1,
724 })
725 .collect();
726 let mut index = vec![EntryScratch::EMPTY; assignments.len()];
727 let mut ids = vec![0u32; assignments.len()];
728 let mut context_refs = [PageRef::EMPTY; 32];
729 let mut entry_refs = [PageRef::EMPTY; 32];
730 let mut publisher = PlainPublisher::prepare(
731 &source,
732 BundleReadLimits::default(),
733 &assignments,
734 PublisherOptions {
735 parameters,
736 class: PublicationClass::PlainCandidate,
737 metadata_limit: MAX_METADATA,
738 },
739 &mut index,
740 &mut ids,
741 &mut context_refs,
742 &mut entry_refs,
743 )
744 .unwrap();
745 let mut output = vec![0; MAX_ENCODED];
746 let mut scratch = vec![0; HASH_SCRATCH_BYTES];
747 for page in 0..publisher.page_count() {
748 publisher
749 .emit_context_page(page, &mut output, &mut scratch, |_, _| Ok(()))
750 .unwrap();
751 }
752 let n = publisher
753 .encode_context_root(&mut output, &mut scratch)
754 .unwrap();
755 let context = output[..n].to_vec();
756 let mut entry_page = Vec::new();
757 for page in 0..publisher.page_count() {
758 publisher
759 .emit_entry_page(
760 page,
761 &mut output,
762 &mut scratch,
763 |_, _| Ok(()),
764 |bytes, _| {
765 entry_page = bytes.to_vec();
766 Ok(())
767 },
768 )
769 .unwrap();
770 }
771 let identity = publisher
772 .finish(&context, &mut output, &mut scratch)
773 .unwrap();
774 let n = publisher.body_encoded_length(&context).unwrap();
775 let body = output[..n].to_vec();
776 drop(publisher);
777 let (ml_pk, ml_sk) = ml_dsa_65::KG::keygen_from_seed(&[71; 32]);
778 let ed_sk = SigningKey::from_bytes(&[72; 32]);
779 let ed_pk = ed_sk.verifying_key().to_bytes();
780 Self {
781 nodes,
782 edges,
783 fields,
784 manifest,
785 body,
786 source,
787 entry_page,
788 identity,
789 ml_sk,
790 ml_pk: ml_pk.into_bytes(),
791 ed_sk,
792 ed_pk,
793 }
794 }
795 fn keys(&self) -> cose::PairedPublicKeys<'_> {
796 cose::PairedPublicKeys {
797 ml_dsa_65: &self.ml_pk,
798 ed25519: &self.ed_pk,
799 }
800 }
801 fn installed(&self, purpose: &[u8]) -> (PinAuthority, LocalBootstrap, PinHandle, PinHandle) {
802 let (mut pins, admin) = PinAuthority::new_local_bootstrap().unwrap();
803 let handle = pins
804 .install_pin(
805 &admin,
806 PinConfig {
807 principal: self.fields.issuer,
808 provider_epoch: KeyEpoch {
809 controller: 7,
810 epoch: 1,
811 purpose: KeyPurpose::ControllerSign,
812 },
813 keys: self.keys(),
814 purpose,
815 audience: b"reader",
816 not_before_unix: 10,
817 expires_unix: 100,
818 },
819 10,
820 )
821 .unwrap();
822 let publisher = pins
823 .install_pin(
824 &admin,
825 PinConfig {
826 principal: self.fields.issuer,
827 provider_epoch: KeyEpoch {
828 controller: 7,
829 epoch: 1,
830 purpose: KeyPurpose::ControllerSign,
831 },
832 keys: self.keys(),
833 purpose: PUBLICATION_PURPOSE,
834 audience: b"reader",
835 not_before_unix: 10,
836 expires_unix: 100,
837 },
838 10,
839 )
840 .unwrap();
841 (pins, admin, handle, publisher)
842 }
843 fn signed_digest(&self, digest: StrongDigest, purpose: &[u8]) -> Vec<u8> {
844 let binding = cose::Binding {
845 descriptor_digest: &digest.0,
846 key_ids: self.keys().key_ids(),
847 controller_epoch: 1,
848 purpose,
849 audience: b"reader",
850 };
851 let keys = cose::SigningKeys {
852 ml_dsa_65: &self.ml_sk,
853 ed25519: &self.ed_sk,
854 };
855 let mut out = vec![0; cose::MAX_ENVELOPE_BYTES];
856 let n = cose::sign_pair_raw(&binding, &keys, &mut cose::Workspace::new(), &mut out)
857 .unwrap();
858 out.truncate(n);
859 out
860 }
861 fn authenticated<'a>(
862 &'a self,
863 pins: &PinAuthority,
864 pin: PinHandle,
865 now: u64,
866 ) -> crate::bundle::stream::policy::AuthenticatedClosure<'a> {
867 let candidate =
868 verify_closure(self.fields.semantic_root, &self.nodes, &self.edges).unwrap();
869 let signed = self.signed_digest(sha384(&self.manifest), CLOSURE_PURPOSE);
870 authenticate_closure(
871 candidate,
872 &self.manifest,
873 pins,
874 pin,
875 self.keys().key_ids(),
876 1,
877 b"reader",
878 &signed,
879 now,
880 &mut cose::Workspace::new(),
881 )
882 .unwrap()
883 }
884 fn bound<'a>(
885 &'a self,
886 pins: &PinAuthority,
887 pin: PinHandle,
888 publisher: PinHandle,
889 ) -> BoundClosure<'a> {
890 self.authenticated(pins, pin, 10)
891 .bind_descriptor(
892 self.identity,
893 &self.body,
894 &mut vec![0; HASH_SCRATCH_BYTES],
895 pins,
896 self.publication(
897 publisher,
898 &self.signed_digest(self.identity.descriptor_id(), PUBLICATION_PURPOSE),
899 ),
900 10,
901 &mut cose::Workspace::new(),
902 )
903 .unwrap()
904 }
905 fn publication<'a>(&self, pin: PinHandle, envelope: &'a [u8]) -> PublicationProof<'a> {
906 PublicationProof {
907 pin,
908 key_ids: self.keys().key_ids(),
909 epoch: 1,
910 audience: b"reader",
911 envelope,
912 }
913 }
914 fn request(&self) -> LocalGrantRequest {
915 LocalGrantRequest {
916 principal: StrongDigest([41; 48]),
917 recipient: StrongDigest([42; 48]),
918 purpose: sha384(b"local-read"),
919 operation: OperationId([1; 16]),
920 not_before: 10,
921 expires: 90,
922 resource_ceiling: self.fields.source_length,
923 }
924 }
925 }
926
927 fn four_live() -> [(&'static str, &'static str, &'static [u8], u32); 4] {
928 [
929 ("qac-opaque", "qac", QAC_OPAQUE, ID_QAC_OPAQUE),
930 ("qac-pcm", "qac", QAC_PCM, ID_QAC_PCM),
931 ("emf-opaque", "emf", EMF_OPAQUE, ID_EMF_OPAQUE),
932 ("emf-align", "emf", EMF_ALIGN, ID_EMF_ALIGN),
933 ]
934 }
935
936 fn q42_volume_bytes() -> Vec<u8> {
937 let subject = hash_token("urn:q42:authenticated-subject");
938 let predicate = hash_token("urn:q42:authenticated-predicate");
939 let object = hash_token("urn:q42:authenticated-object");
940 let quin = NQuin {
941 subject,
942 predicate,
943 object,
944 context: 0,
945 metadata: 0,
946 parity: 0,
947 };
948 let mut lexicon = HashMap::new();
949 lexicon.insert(subject, "urn:q42:authenticated-subject".to_string());
950 lexicon.insert(predicate, "urn:q42:authenticated-predicate".to_string());
951 lexicon.insert(object, "urn:q42:authenticated-object".to_string());
952 let file = NamedTempFile::new().unwrap();
953 write_unified_volume(file.path(), &lexicon, &[(object, object)], &[vec![quin]]).unwrap();
954 let mut q42 = Vec::new();
955 std::fs::File::open(file.path())
956 .unwrap()
957 .read_to_end(&mut q42)
958 .unwrap();
959 assert!(!q42.is_empty());
960 assert!(q42.len() as u64 <= LEAF_BYTES);
961 assert!(q42.len() as u64 <= LEGACY_FULL_OBJECT_FALLBACK_BYTES);
962 q42
963 }
964
965 fn family_of(id: u32) -> EntryFamily {
966 match id {
967 ID_QAC_OPAQUE | ID_QAC_PCM => EntryFamily::Qac,
968 ID_EMF_OPAQUE | ID_EMF_ALIGN => EntryFamily::Emf,
969 ID_M64 => EntryFamily::M64,
970 ID_Q42 => EntryFamily::Q42,
971 ID_CALIB => EntryFamily::Q42,
972 _ => EntryFamily::Opaque,
973 }
974 }
975
976 fn plan_entry(
977 candidate: CandidateIdentity,
978 entry_id: u32,
979 family: EntryFamily,
980 role: RepresentationClass,
981 obligation: Obligation,
982 bytes: u64,
983 ) -> PlanEntry {
984 PlanEntry::new(PlanEntrySpec {
985 candidate,
986 entry_id,
987 family,
988 role,
989 interval: None,
990 timebase: None,
991 estimate: ResourceEstimate::new(bytes, 1, 1),
992 obligation,
993 })
994 .unwrap()
995 }
996
997 fn select_all<'p>(bound: &BoundClosure<'_>, scene: &'p Scene) -> Vec<SelectedPlainEntry<'p>> {
998 let header = admit_header(
999 &scene.source()[..64],
1000 scene.source().len() as u64,
1001 ExtentLimit::default(),
1002 IndexReadLimits::default(),
1003 )
1004 .unwrap();
1005 let count = scene.identity().entry_count() as usize;
1006 let mut index_scratch = vec![EntryScratch::EMPTY; count];
1007 let index = admit_index(
1008 &header,
1009 &scene.source()[header.index_offset() as usize..],
1010 IndexReadLimits::default(),
1011 &mut index_scratch,
1012 )
1013 .unwrap();
1014 let mut rows = [EntryRecord::EMPTY; 128];
1015 let mut framing = vec![0; HASH_SCRATCH_BYTES];
1016 let mut out = Vec::with_capacity(count);
1017 for ordinal in 0..count as u32 {
1018 out.push(
1019 select_entry(
1020 bound,
1021 scene.body(),
1022 &scene.source()[..64],
1023 &index,
1024 scene.entry_page(),
1025 ordinal,
1026 &mut rows,
1027 &mut framing,
1028 )
1029 .unwrap(),
1030 );
1031 }
1032 out
1033 }
1034
1035 fn build_outboard(
1036 source: &[u8],
1037 selected: SelectedPlainEntry<'_>,
1038 ) -> (Vec<OutboardNode>, StrongDigest) {
1039 let entry = entry_slice(source, selected).unwrap();
1040 let spec = selected.tree_spec().unwrap();
1041 let mut builder = TreeBuilder::new(spec);
1042 let mut nodes = Vec::new();
1043 for leaf in entry.chunks(LEAF_BYTES as usize) {
1044 builder
1045 .append(leaf, |node| {
1046 nodes.push(node);
1047 Ok(())
1048 })
1049 .unwrap();
1050 }
1051 let root = builder
1052 .finish(|node| {
1053 nodes.push(node);
1054 Ok(())
1055 })
1056 .unwrap();
1057 assert_eq!(root, selected.root());
1058 nodes.sort_unstable_by_key(|node| (node.start_leaf, node.leaf_count));
1059 (nodes, root)
1060 }
1061
1062 fn outboards(
1063 source: &[u8],
1064 selected: &[SelectedPlainEntry<'_>],
1065 ) -> (Vec<Vec<OutboardNode>>, Vec<StrongDigest>) {
1066 let mut nodes = Vec::new();
1067 let mut roots = Vec::new();
1068 for sel in selected {
1069 let (n, r) = build_outboard(source, *sel);
1070 nodes.push(n);
1071 roots.push(r);
1072 }
1073 (nodes, roots)
1074 }
1075
1076 fn bind_entries<'src, 'sel, 'nodes, 'meta>(
1077 source: &'src [u8],
1078 selected: &[SelectedPlainEntry<'sel>],
1079 nodes: &'nodes [Vec<OutboardNode>],
1080 roots: &[StrongDigest],
1081 descriptor: &'meta [u8],
1082 entry_page: &'meta [u8],
1083 ) -> Vec<BoundHttpEntry<'src, 'sel, 'nodes, 'meta>> {
1084 selected
1085 .iter()
1086 .zip(nodes.iter())
1087 .zip(roots.iter())
1088 .map(|((sel, nodes), root)| {
1089 bind_http_entry(source, *sel, nodes, *root, descriptor, entry_page).unwrap()
1090 })
1091 .collect()
1092 }
1093
1094 fn present_admitted(source: &[u8], selected: &[SelectedPlainEntry<'_>]) -> Vec<u32> {
1095 let mut present = Vec::new();
1096 for sel in selected {
1097 let family = family_of(sel.entry_id());
1098 if family == EntryFamily::Qac
1099 || family == EntryFamily::Emf
1100 || family == EntryFamily::Q42
1101 {
1102 if entry_admits_family(source, *sel, family) {
1103 present.push(sel.entry_id());
1104 }
1105 } else if family != EntryFamily::Opaque {
1106 present.push(sel.entry_id());
1107 }
1108 }
1109 present
1110 }
1111
1112 fn live_plan(
1113 candidate: CandidateIdentity,
1114 ids: &[u32],
1115 selected: &[SelectedPlainEntry<'_>],
1116 ) -> Vec<PlanEntry> {
1117 ids.iter()
1118 .map(|id| {
1119 let bytes = selected
1120 .iter()
1121 .find(|s| s.entry_id() == *id)
1122 .map(|s| s.logical_length())
1123 .unwrap_or(1);
1124 plan_entry(
1125 candidate,
1126 *id,
1127 family_of(*id),
1128 RepresentationClass::Base,
1129 Obligation::Mandatory,
1130 bytes,
1131 )
1132 })
1133 .collect()
1134 }
1135
1136 fn selected_by_id<'p>(
1137 selected: &[SelectedPlainEntry<'p>],
1138 id: u32,
1139 ) -> SelectedPlainEntry<'p> {
1140 *selected.iter().find(|s| s.entry_id() == id).unwrap()
1141 }
1142
1143 fn ledger() -> ReservationLedger {
1144 let cap = ResourceBudget {
1145 bytes: 8 << 20,
1146 work: 64,
1147 io: 64,
1148 };
1149 ReservationLedger::new(cap, cap, cap, cap, cap)
1150 }
1151
1152 fn spawn_http(
1153 status: u16,
1154 hdrs: Vec<(String, String)>,
1155 body: Vec<u8>,
1156 ) -> (
1157 std::net::SocketAddr,
1158 Arc<Mutex<Vec<u8>>>,
1159 thread::JoinHandle<()>,
1160 ) {
1161 let listener = TcpListener::bind("127.0.0.1:0").unwrap();
1162 let addr = listener.local_addr().unwrap();
1163 let captured = Arc::new(Mutex::new(Vec::new()));
1164 let cap = captured.clone();
1165 let th = thread::spawn(move || {
1166 let (mut s, _) = listener.accept().unwrap();
1167 s.set_read_timeout(Some(Duration::from_secs(2))).ok();
1168 s.set_write_timeout(Some(Duration::from_secs(2))).ok();
1169 let mut buf = [0u8; HEADER_CAP];
1170 let mut n = 0;
1171 while n < buf.len() {
1172 match s.read(&mut buf[n..]) {
1173 Ok(0) => break,
1174 Ok(k) => {
1175 n += k;
1176 if buf[..n].windows(4).any(|w| w == b"\r\n\r\n") {
1177 break;
1178 }
1179 }
1180 Err(_) => break,
1181 }
1182 }
1183 *cap.lock().unwrap() = buf[..n].to_vec();
1184 let mut resp = format!("HTTP/1.1 {status} X\r\n");
1185 for (k, v) in &hdrs {
1186 resp.push_str(k);
1187 resp.push_str(": ");
1188 resp.push_str(v);
1189 resp.push_str("\r\n");
1190 }
1191 resp.push_str("\r\n");
1192 let _ = s.write_all(resp.as_bytes());
1193 let _ = s.write_all(&body);
1194 let _ = s.flush();
1195 });
1196 (addr, captured, th)
1197 }
1198
1199 fn connect(addr: std::net::SocketAddr) -> TcpStream {
1200 let s = TcpStream::connect(addr).unwrap();
1201 s.set_read_timeout(Some(Duration::from_secs(2))).unwrap();
1202 s.set_write_timeout(Some(Duration::from_secs(2))).unwrap();
1203 s
1204 }
1205
1206 fn object_body<'a>(out: &'a [u8], object: &ServedObject) -> &'a [u8] {
1207 &out[object.body_off..object.body_off + object.body_len]
1208 }
1209
1210 #[test]
1211 fn schedule_order_matches_native_bytes_over_http() {
1212 assert!(!tls_is_pq_publisher_authority());
1213 let scene = Scene::publish(&four_live());
1214 let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1215 let bound = scene.bound(&pins, pin, publisher);
1216 let local = select_all(&bound, &scene);
1217 assert_eq!(local.len(), 4);
1218 let (nodes, roots) = outboards(scene.source(), &local);
1219 let entries = bind_entries(
1220 scene.source(),
1221 &local,
1222 &nodes,
1223 &roots,
1224 scene.body(),
1225 scene.entry_page(),
1226 );
1227 let present = present_admitted(scene.source(), &local);
1228 assert_eq!(present.len(), 4);
1229 let ids = [ID_QAC_OPAQUE, ID_QAC_PCM, ID_EMF_OPAQUE, ID_EMF_ALIGN];
1230 let plan_entries = live_plan(scene.identity(), &ids, &local);
1231 let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1232 let intents = [
1233 SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1234 SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1235 SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1236 SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1237 ];
1238 let request = SelectionRequest::scene(&intents).unwrap();
1239 let sel = PrincipalSelection::new(1, request).unwrap();
1240 let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1241 Ok(m) => m,
1242 Err(_) => panic!("four live families must compile"),
1243 };
1244 mux.push_control(1, RecordUnit::at(0)).unwrap();
1245 let mut owner = AuthorityOwner::new();
1246 let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1247 let mut ledger = ledger();
1248 let mut out = vec![0u8; 64 * 1024];
1249 let report = match serve_scheduled(
1250 &mut mux,
1251 &entries,
1252 &mut grant,
1253 &pins,
1254 || 20,
1255 &mut ledger,
1256 &mut out,
1257 ) {
1258 Ok(r) => r,
1259 Err(_) => panic!("four live families must serve over HTTP"),
1260 };
1261 assert_eq!(report.control, 1);
1262 assert_eq!(report.transferred, 4);
1263 if report.order_len > 0 {
1264 assert_eq!(report.order[0], None);
1265 }
1266 let mut saw_qac = 0u16;
1267 let mut saw_emf = 0u16;
1268 for i in 0..report.order_len as usize {
1269 match report.order[i] {
1270 None => {}
1271 Some(EntryFamily::Qac) => saw_qac += 1,
1272 Some(EntryFamily::Emf) => saw_emf += 1,
1273 Some(_) => panic!("only QAC/EMF/Control in this scene"),
1274 }
1275 }
1276 assert_eq!(saw_qac, 2);
1277 assert_eq!(saw_emf, 2);
1278 let mut charged = 0u64;
1279 let mut first_object = None;
1280 for i in 0..report.objects_len as usize {
1281 let object = match report.objects[i] {
1282 Some(o) => o,
1283 None => panic!("served object slot"),
1284 };
1285 assert!(object.status == 206 || object.status == 200);
1286 let sel = selected_by_id(&local, object.entry_id);
1287 let native = entry_slice(scene.source(), sel).unwrap();
1288 assert_eq!(object_body(&out, &object), native);
1289 assert!(entry_admits_family(scene.source(), sel, object.family));
1290 charged = charged.saturating_add(object.body_len as u64);
1291 if first_object.is_none() {
1292 first_object = Some((object, native.to_vec()));
1293 }
1294 }
1295 assert_eq!(ledger.used().host.bytes, charged);
1296
1297 let (object, native) = match first_object {
1298 Some(v) => v,
1299 None => panic!("at least one representation"),
1300 };
1301 let mut cr = [0u8; 80];
1302 let range = InclusiveRange::from_start_length(0, native.len() as u64).unwrap();
1303 let cn = write_content_range(range, native.len() as u64, &mut cr).unwrap();
1304 let etag_s = std::str::from_utf8(&object.etag[..object.etag_len])
1305 .unwrap()
1306 .to_string();
1307 let (addr, captured, th) = spawn_http(
1308 object.status,
1309 vec![
1310 (
1311 "Content-Range".into(),
1312 String::from_utf8_lossy(&cr[..cn]).into_owned(),
1313 ),
1314 ("Content-Length".into(), native.len().to_string()),
1315 ("Content-Encoding".into(), "identity".into()),
1316 ("ETag".into(), etag_s),
1317 ],
1318 native.clone(),
1319 );
1320 let host = format!("{addr}").into_bytes();
1321 let req = RangeRequest {
1322 host: &host,
1323 path: PATH,
1324 range,
1325 pinned_total: native.len() as u64,
1326 if_range: Some(&object.etag[..object.etag_len]),
1327 expected: Validator {
1328 etag: Some(&object.etag[..object.etag_len]),
1329 last_modified: None,
1330 },
1331 fallback: FallbackPolicy::FORBIDDEN,
1332 budget: FetchBudget {
1333 max_body: LEGACY_FULL_OBJECT_FALLBACK_BYTES,
1334 max_headers: HEADER_CAP,
1335 },
1336 lig: LigGate::consented_active(),
1337 };
1338 let mut stream = connect(addr);
1339 let mut client_out = vec![0u8; native.len()];
1340 let got = match get_range(&mut stream, &req, &mut client_out) {
1341 Ok(v) => v,
1342 Err(_) => panic!("hostile loopback must return the native slice"),
1343 };
1344 assert_eq!(
1345 got,
1346 Fetched::Partial {
1347 length: native.len()
1348 }
1349 );
1350 assert_eq!(&client_out[..native.len()], native.as_slice());
1351 let text = String::from_utf8_lossy(&captured.lock().unwrap()).into_owned();
1352 assert!(text.contains("Accept-Encoding: identity"));
1353 assert!(text.contains("Range: bytes="));
1354 assert!(text.contains("If-Range: "));
1355 assert!(!text.contains("Authorization:"));
1356 th.join().unwrap();
1357 }
1358
1359 #[test]
1360 fn http_delays_m64_while_ready_qac_and_emf_continue() {
1361 let mut files = four_live().to_vec();
1362 files.push(("m64-delay", "blob", M64_BYTES, ID_M64));
1363 let scene = Scene::publish(&files);
1364 let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1365 let bound = scene.bound(&pins, pin, publisher);
1366 let local = select_all(&bound, &scene);
1367 let (nodes, roots) = outboards(scene.source(), &local);
1368 let entries = bind_entries(
1369 scene.source(),
1370 &local,
1371 &nodes,
1372 &roots,
1373 scene.body(),
1374 scene.entry_page(),
1375 );
1376 let present = present_admitted(scene.source(), &local);
1377 assert!(present.contains(&ID_QAC_OPAQUE));
1378 assert!(present.contains(&ID_EMF_OPAQUE));
1379 assert!(present.contains(&ID_M64));
1380 let ids = [
1381 ID_QAC_OPAQUE,
1382 ID_QAC_PCM,
1383 ID_EMF_OPAQUE,
1384 ID_EMF_ALIGN,
1385 ID_M64,
1386 ];
1387 let plan_entries = live_plan(scene.identity(), &ids, &local);
1388 let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1389 let intents = [
1390 SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1391 SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1392 SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1393 SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1394 SelectionIntent::scene(ID_M64, EntryFamily::M64, None, None).unwrap(),
1395 ];
1396 let request = SelectionRequest::scene(&intents).unwrap();
1397 let sel = PrincipalSelection::new(1, request).unwrap();
1398 let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1399 Ok(m) => m,
1400 Err(_) => panic!("live QAC/EMF plus delayed M64 must compile"),
1401 };
1402 mux.push_control(1, RecordUnit::at(0)).unwrap();
1403 let mut owner = AuthorityOwner::new();
1404 let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1405 let mut ledger = ledger();
1406 let mut out = vec![0u8; 64 * 1024];
1407 let report = match serve_scheduled(
1408 &mut mux,
1409 &entries,
1410 &mut grant,
1411 &pins,
1412 || 20,
1413 &mut ledger,
1414 &mut out,
1415 ) {
1416 Ok(r) => r,
1417 Err(_) => panic!("live QAC/EMF plus delayed M64 must serve"),
1418 };
1419 assert!(report.delayed_deferred >= 1);
1420 assert_eq!(report.control, 1);
1421 assert_eq!(report.transferred, 5);
1422 let mut saw_m64 = false;
1423 for i in 0..report.order_len as usize {
1424 match report.order[i] {
1425 None | Some(EntryFamily::Qac) | Some(EntryFamily::Emf) => {
1426 assert!(!saw_m64, "M64 must wait on live families");
1427 }
1428 Some(EntryFamily::M64) => {
1429 assert!(i > 0, "Control/QAC/EMF run before M64");
1430 saw_m64 = true;
1431 }
1432 Some(_) => panic!("unexpected family in delay scene"),
1433 }
1434 }
1435 assert!(saw_m64);
1436 let first_body = match report.objects[0] {
1437 Some(o) => o,
1438 None => panic!("first served representation"),
1439 };
1440 assert!(
1441 first_body.family == EntryFamily::Qac || first_body.family == EntryFamily::Emf,
1442 "first HTTP body is a live family"
1443 );
1444 }
1445
1446 #[test]
1447 fn http_cancel_obsolete_qac_skips_body() {
1448 let scene = Scene::publish(&four_live());
1449 let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1450 let bound = scene.bound(&pins, pin, publisher);
1451 let local = select_all(&bound, &scene);
1452 let (nodes, roots) = outboards(scene.source(), &local);
1453 let entries = bind_entries(
1454 scene.source(),
1455 &local,
1456 &nodes,
1457 &roots,
1458 scene.body(),
1459 scene.entry_page(),
1460 );
1461 let present = present_admitted(scene.source(), &local);
1462 let ids = [ID_QAC_OPAQUE, ID_QAC_PCM, ID_EMF_OPAQUE, ID_EMF_ALIGN];
1463 let plan_entries = live_plan(scene.identity(), &ids, &local);
1464 let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1465 let intents = [
1466 SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1467 SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1468 SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1469 SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1470 ];
1471 let request = SelectionRequest::scene(&intents).unwrap();
1472 let sel = PrincipalSelection::new(1, request).unwrap();
1473 let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1474 Ok(m) => m,
1475 Err(_) => panic!("cancel scene must compile"),
1476 };
1477 let cancelled = mux.cancel(ID_QAC_OPAQUE, None);
1478 assert!(cancelled >= 1);
1479 assert!(mux.occupancy_retained(1, Some(ID_QAC_OPAQUE), 0));
1480 let mut owner = AuthorityOwner::new();
1481 let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1482 let mut ledger = ledger();
1483 let mut out = vec![0u8; 64 * 1024];
1484 let report = match serve_scheduled(
1485 &mut mux,
1486 &entries,
1487 &mut grant,
1488 &pins,
1489 || 20,
1490 &mut ledger,
1491 &mut out,
1492 ) {
1493 Ok(r) => r,
1494 Err(_) => panic!("sibling EMF must continue after QAC cancel"),
1495 };
1496 assert!(report.cancelled_skipped >= 1);
1497 assert_eq!(report.transferred, 3);
1498 let mut saw_emf = 0u16;
1499 let mut saw_qac = 0u16;
1500 for i in 0..report.objects_len as usize {
1501 let object = match report.objects[i] {
1502 Some(o) => o,
1503 None => panic!("served object slot"),
1504 };
1505 assert_ne!(object.entry_id, ID_QAC_OPAQUE);
1506 assert!(object.status == 206 || object.status == 200);
1507 let sel = selected_by_id(&local, object.entry_id);
1508 let native = entry_slice(scene.source(), sel).unwrap();
1509 assert_eq!(object_body(&out, &object), native);
1510 match object.family {
1511 EntryFamily::Qac => saw_qac += 1,
1512 EntryFamily::Emf => saw_emf += 1,
1513 _ => panic!("unexpected family after cancel"),
1514 }
1515 }
1516 assert_eq!(saw_emf, 2);
1517 assert_eq!(saw_qac, 1);
1518 assert!(mux.occupancy_retained(1, Some(ID_QAC_OPAQUE), 0));
1519 mux.acknowledge_complete(1, Some(ID_QAC_OPAQUE), 0).unwrap();
1520 assert!(!mux.occupancy_retained(1, Some(ID_QAC_OPAQUE), 0));
1521 }
1522
1523 #[test]
1524 fn http_incomplete_mandatory_is_not_200_or_206() {
1525 let scene = Scene::publish(&four_live());
1526 let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1527 let bound = scene.bound(&pins, pin, publisher);
1528 let local = select_all(&bound, &scene);
1529 let (nodes, roots) = outboards(scene.source(), &local);
1530 let entries = bind_entries(
1531 scene.source(),
1532 &local,
1533 &nodes,
1534 &roots,
1535 scene.body(),
1536 scene.entry_page(),
1537 );
1538 let present = present_admitted(scene.source(), &local);
1539 let mut plan_entries = live_plan(scene.identity(), &present, &local);
1540 plan_entries.push(plan_entry(
1541 scene.identity(),
1542 ID_CALIB,
1543 EntryFamily::Q42,
1544 RepresentationClass::Metadata,
1545 Obligation::Mandatory,
1546 7,
1547 ));
1548 let qac0 = plan_entries
1549 .iter()
1550 .find(|e| e.entry_id() == ID_QAC_OPAQUE)
1551 .copied()
1552 .unwrap();
1553 let emf0 = plan_entries
1554 .iter()
1555 .find(|e| e.entry_id() == ID_EMF_OPAQUE)
1556 .copied()
1557 .unwrap();
1558 let calib = plan_entries
1559 .iter()
1560 .find(|e| e.entry_id() == ID_CALIB)
1561 .copied()
1562 .unwrap();
1563 let edges = [
1564 DependencyEdge::bind(
1565 &qac0,
1566 &calib,
1567 Obligation::Mandatory,
1568 DependencyReason::Calibration,
1569 )
1570 .unwrap(),
1571 DependencyEdge::bind(
1572 &emf0,
1573 &calib,
1574 Obligation::Mandatory,
1575 DependencyReason::Calibration,
1576 )
1577 .unwrap(),
1578 ];
1579 let inv = Inventory::compile(scene.identity(), &plan_entries, &edges).unwrap();
1580 let intents = [
1581 SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1582 SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1583 ];
1584 let request = SelectionRequest::scene(&intents).unwrap();
1585 let sel = PrincipalSelection::new(1, request).unwrap();
1586 let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1587 Ok(m) => m,
1588 Err(_) => panic!("incomplete scene still compiles; serve must refuse"),
1589 };
1590 let mut owner = AuthorityOwner::new();
1591 let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1592 let mut ledger = ledger();
1593 let mut out = [0xA5u8; 64];
1594 match serve_scheduled(
1595 &mut mux,
1596 &entries,
1597 &mut grant,
1598 &pins,
1599 || 20,
1600 &mut ledger,
1601 &mut out,
1602 ) {
1603 Err(ProviderError::Policy) | Err(ProviderError::Unsatisfiable) => {}
1604 Ok(_) => panic!("missing mandatory must not disclose 200/206"),
1605 Err(_) => panic!("missing mandatory maps to Policy or Unsatisfiable"),
1606 }
1607 assert!(out.iter().all(|b| *b == 0xA5));
1608 assert_eq!(ledger.used().host.bytes, 0);
1609 }
1610
1611 #[test]
1612 fn http_two_qac_and_two_emf_are_distinct_objects() {
1613 let scene = Scene::publish(&four_live());
1614 let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1615 let bound = scene.bound(&pins, pin, publisher);
1616 let local = select_all(&bound, &scene);
1617 let (nodes, roots) = outboards(scene.source(), &local);
1618 let entries = bind_entries(
1619 scene.source(),
1620 &local,
1621 &nodes,
1622 &roots,
1623 scene.body(),
1624 scene.entry_page(),
1625 );
1626 let present = present_admitted(scene.source(), &local);
1627 let ids = [ID_QAC_OPAQUE, ID_QAC_PCM, ID_EMF_OPAQUE, ID_EMF_ALIGN];
1628 let plan_entries = live_plan(scene.identity(), &ids, &local);
1629 let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1630 let intents = [
1631 SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1632 SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1633 SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1634 SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1635 ];
1636 let request = SelectionRequest::scene(&intents).unwrap();
1637 let sel = PrincipalSelection::new(1, request).unwrap();
1638 let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1639 Ok(m) => m,
1640 Err(_) => panic!("four distinct objects must compile"),
1641 };
1642 let mut owner = AuthorityOwner::new();
1643 let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1644 let mut ledger = ledger();
1645 let mut out = vec![0u8; 64 * 1024];
1646 let report = match serve_scheduled(
1647 &mut mux,
1648 &entries,
1649 &mut grant,
1650 &pins,
1651 || 20,
1652 &mut ledger,
1653 &mut out,
1654 ) {
1655 Ok(r) => r,
1656 Err(_) => panic!("four distinct objects must serve"),
1657 };
1658 assert_eq!(report.transferred, 4);
1659 assert_eq!(report.objects_len, 4);
1660 let mut ids_seen = [0u32; 4];
1661 let mut etags = [[0u8; 98]; 4];
1662 let mut roots_seen = [StrongDigest::ZERO; 4];
1663 for i in 0..4 {
1664 let object = match report.objects[i] {
1665 Some(o) => o,
1666 None => panic!("four objects"),
1667 };
1668 assert!(object.status == 206 || object.status == 200);
1669 ids_seen[i] = object.entry_id;
1670 etags[i] = object.etag;
1671 let sel = selected_by_id(&local, object.entry_id);
1672 roots_seen[i] = sel.root();
1673 let native = entry_slice(scene.source(), sel).unwrap();
1674 assert_eq!(object_body(&out, &object), native);
1675 let mut expect_etag = [0u8; 98];
1676 write_strong_etag(sel.root(), &mut expect_etag).unwrap();
1677 assert_eq!(&object.etag[..object.etag_len], &expect_etag[..98]);
1678 }
1679 for i in 0..4 {
1680 for j in 0..i {
1681 assert_ne!(ids_seen[i], ids_seen[j]);
1682 assert_ne!(etags[i], etags[j]);
1683 assert_ne!(roots_seen[i], roots_seen[j]);
1684 }
1685 }
1686 let mut saw_qac = 0u16;
1687 let mut saw_emf = 0u16;
1688 for i in 0..4 {
1689 match report.objects[i].map(|o| o.family) {
1690 Some(EntryFamily::Qac) => saw_qac += 1,
1691 Some(EntryFamily::Emf) => saw_emf += 1,
1692 _ => panic!("only QAC/EMF objects"),
1693 }
1694 }
1695 assert_eq!(saw_qac, 2);
1696 assert_eq!(saw_emf, 2);
1697 }
1698
1699 #[test]
1700 fn http_q42_range_matches_authenticated_source() {
1701 assert!(!tls_is_pq_publisher_authority());
1702 let q42 = q42_volume_bytes();
1703 assert!(q42.len() > 256);
1704 let take = 128usize;
1705 let mut files = four_live().to_vec();
1706 files.push(("q42-query", "q42", q42.as_slice(), ID_Q42));
1707 let scene = Scene::publish(&files);
1708 let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1709 let bound = scene.bound(&pins, pin, publisher);
1710 let local = select_all(&bound, &scene);
1711 let selected = selected_by_id(&local, ID_Q42);
1712 let payload = entry_slice(scene.source(), selected).unwrap();
1713 assert_eq!(payload, q42.as_slice());
1714 assert!(entry_admits_family(scene.source(), selected, EntryFamily::Q42));
1715
1716 let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
1717 let span = match whole_span(selected, payload, &mut siblings) {
1718 Ok(s) => s,
1719 Err(_) => panic!("q42 whole-entry span"),
1720 };
1721 let whole = match AuthenticatedRange::new(selected, &span, 0, payload.len()) {
1722 Ok(r) => r,
1723 Err(_) => panic!("q42 whole-entry authenticated range"),
1724 };
1725 let ranges = [whole];
1726 let source = match Q42AuthenticatedRangeSource::new(
1727 selected,
1728 &ranges,
1729 q42.len() as u64,
1730 1,
1731 ) {
1732 Ok(s) => s,
1733 Err(_) => panic!("q42 authenticated range source"),
1734 };
1735 let volume = match Q42RangeVolume::open(source) {
1736 Ok(v) => v,
1737 Err(_) => panic!("whole-entry q42 must open"),
1738 };
1739 assert!(volume.block_count() >= 1);
1740 let source = volume.into_source();
1741 let mut native_window = vec![0u8; take];
1742 match source.read_exact_at(0, &mut native_window) {
1743 Ok(()) => {}
1744 Err(_) => panic!("authenticated q42 window"),
1745 }
1746 match source.read_range_into(
1747 Q42ByteRange {
1748 offset: 0,
1749 length: take,
1750 },
1751 &mut native_window,
1752 ) {
1753 Ok(()) => {}
1754 Err(_) => panic!("authenticated q42 read_range_into"),
1755 }
1756 assert_eq!(&native_window, &q42[..take]);
1757
1758 let left = match AuthenticatedRange::new(selected, &span, 0, 8) {
1759 Ok(r) => r,
1760 Err(_) => panic!("q42 left span"),
1761 };
1762 let right_start = q42.len().saturating_sub(8);
1763 let right = match AuthenticatedRange::new(
1764 selected,
1765 &span,
1766 right_start as u64,
1767 q42.len() - right_start,
1768 ) {
1769 Ok(r) => r,
1770 Err(_) => panic!("q42 right span"),
1771 };
1772 let sparse_ranges = [left, right];
1773 let sparse = match Q42AuthenticatedRangeSource::new(
1774 selected,
1775 &sparse_ranges,
1776 q42.len() as u64,
1777 2,
1778 ) {
1779 Ok(s) => s,
1780 Err(_) => panic!("q42 sparse source"),
1781 };
1782 let mut untouched = [0xa5u8; 4];
1783 match sparse.read_exact_at(8, &mut untouched) {
1784 Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof),
1785 Ok(()) => panic!("gap must not be a complete q42 answer"),
1786 }
1787 assert_eq!(untouched, [0xa5u8; 4]);
1788
1789 let partial = match AuthenticatedRange::new(selected, &span, 0, take) {
1790 Ok(r) => r,
1791 Err(_) => panic!("q42 partial range"),
1792 };
1793 let partial_ranges = [partial];
1794 let partial_source = match Q42AuthenticatedRangeSource::new(
1795 selected,
1796 &partial_ranges,
1797 q42.len() as u64,
1798 1,
1799 ) {
1800 Ok(s) => s,
1801 Err(_) => panic!("q42 partial source"),
1802 };
1803 match Q42RangeVolume::open(partial_source) {
1804 Err(_) => {}
1805 Ok(_) => panic!("partial header/lex window must not open as a complete volume"),
1806 }
1807 let partial_source = match Q42AuthenticatedRangeSource::new(
1808 selected,
1809 &partial_ranges,
1810 q42.len() as u64,
1811 1,
1812 ) {
1813 Ok(s) => s,
1814 Err(_) => panic!("q42 partial source retry"),
1815 };
1816 let mut beyond = [0xa5u8; 4];
1817 match partial_source.read_exact_at(take as u64, &mut beyond) {
1818 Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof),
1819 Ok(()) => panic!("uncovered q42 bytes must not silently complete"),
1820 }
1821 assert_eq!(beyond, [0xa5u8; 4]);
1822
1823 let (nodes, root) = build_outboard(scene.source(), selected);
1824 let bound_entry = match bind_http_entry(
1825 scene.source(),
1826 selected,
1827 &nodes,
1828 root,
1829 scene.body(),
1830 scene.entry_page(),
1831 ) {
1832 Ok(e) => e,
1833 Err(_) => panic!("q42 http bind"),
1834 };
1835 let range = InclusiveRange::from_start_length(0, take as u64).unwrap();
1836 let mut owner = AuthorityOwner::new();
1837 let mut grant =
1838 adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1839 let mut ledger = ledger();
1840 let mut window = vec![0u8; take];
1841 let mut full_out = vec![0u8; q42.len()];
1842 let mut served_status = 0u16;
1843 let mut served_len = 0usize;
1844 let mut served_etag = [0u8; 98];
1845 let mut served_etag_len = 0usize;
1846 let mut served_cr = [0u8; 80];
1847 let mut served_cr_len = 0usize;
1848 let mut full_status = 0u16;
1849 let mut full_len = 0usize;
1850 match grant.accept_local_scoped(&pins, || 20, |authority| {
1851 Ok((|| -> Result<(), ProviderError> {
1852 let served = bound_entry.provider.serve(
1853 HttpObject::Representation,
1854 Some(range),
1855 None,
1856 Validator::NONE,
1857 ServeOptions {
1858 fallback: FallbackPolicy::FORBIDDEN,
1859 verified_peer: true,
1860 },
1861 authority,
1862 &mut ledger,
1863 &mut window,
1864 )?;
1865 if served.status != 206 {
1866 return Err(ProviderError::Unsatisfiable);
1867 }
1868 served_status = served.status;
1869 served_len = served.body_len;
1870 served_etag = served.headers.etag;
1871 served_etag_len = served.headers.etag_len;
1872 served_cr = served.headers.content_range;
1873 served_cr_len = served.headers.content_range_len;
1874 match validate_exact_range_response(
1875 Q42ByteRange {
1876 offset: 0,
1877 length: take,
1878 },
1879 q42.len() as u64,
1880 range.start(),
1881 served.body_len,
1882 ) {
1883 Ok(()) => {}
1884 Err(_) => return Err(ProviderError::Unsatisfiable),
1885 }
1886 let fallback = match FallbackPolicy::explicit(LEGACY_FULL_OBJECT_FALLBACK_BYTES) {
1887 Ok(p) => p,
1888 Err(e) => return Err(ProviderError::Status(e)),
1889 };
1890 let full = bound_entry.provider.serve(
1891 HttpObject::Representation,
1892 None,
1893 None,
1894 Validator::NONE,
1895 ServeOptions {
1896 fallback,
1897 verified_peer: true,
1898 },
1899 authority,
1900 &mut ledger,
1901 &mut full_out,
1902 )?;
1903 if full.status != 200 {
1904 return Err(ProviderError::Unsatisfiable);
1905 }
1906 full_status = full.status;
1907 full_len = full.body_len;
1908 Ok(())
1909 })())
1910 }) {
1911 Ok(Ok(())) => {}
1912 Ok(Err(_)) => panic!("q42 http range provider"),
1913 Err(_) => panic!("q42 http range grant"),
1914 }
1915 assert_eq!(served_status, 206);
1916 assert_eq!(&window[..served_len], native_window.as_slice());
1917 assert_eq!(full_status, 200);
1918 assert_eq!(&full_out[..full_len], q42.as_slice());
1919
1920 let mut cr = [0u8; 80];
1921 let cn = write_content_range(range, q42.len() as u64, &mut cr).unwrap();
1922 assert_eq!(&served_cr[..served_cr_len], &cr[..cn]);
1923 let etag_s = std::str::from_utf8(&served_etag[..served_etag_len])
1924 .unwrap()
1925 .to_string();
1926 let (addr, captured, th) = spawn_http(
1927 served_status,
1928 vec![
1929 (
1930 "Content-Range".into(),
1931 String::from_utf8_lossy(&cr[..cn]).into_owned(),
1932 ),
1933 ("Content-Length".into(), take.to_string()),
1934 ("Content-Encoding".into(), "identity".into()),
1935 ("ETag".into(), etag_s),
1936 ],
1937 native_window.clone(),
1938 );
1939 let host = format!("{addr}").into_bytes();
1940 let req = RangeRequest {
1941 host: &host,
1942 path: b"/objects/mixed/representations/40",
1943 range,
1944 pinned_total: q42.len() as u64,
1945 if_range: Some(&served_etag[..served_etag_len]),
1946 expected: Validator {
1947 etag: Some(&served_etag[..served_etag_len]),
1948 last_modified: None,
1949 },
1950 fallback: FallbackPolicy::FORBIDDEN,
1951 budget: FetchBudget {
1952 max_body: LEGACY_FULL_OBJECT_FALLBACK_BYTES,
1953 max_headers: HEADER_CAP,
1954 },
1955 lig: LigGate::consented_active(),
1956 };
1957 let mut stream = connect(addr);
1958 let mut client_out = vec![0u8; take];
1959 let got = match get_range(&mut stream, &req, &mut client_out) {
1960 Ok(v) => v,
1961 Err(_) => panic!("hostile q42 loopback must return the authenticated window"),
1962 };
1963 assert_eq!(
1964 got,
1965 Fetched::Partial {
1966 length: take
1967 }
1968 );
1969 assert_eq!(&client_out[..take], native_window.as_slice());
1970 let text = String::from_utf8_lossy(&captured.lock().unwrap()).into_owned();
1971 assert!(text.contains("Accept-Encoding: identity"));
1972 assert!(text.contains("Range: bytes="));
1973 assert!(!text.contains("Authorization:"));
1974 th.join().unwrap();
1975 }
1976}