nx_robust_dl_gate.nx source

1import "nx_gate_gn.nx" 2import "nx_gate_base.nx" 3// nx_robust_dl_gate.nx -- proves the robust-download core: TS integrity (reject truncated/garbage), fragment 4// retry (fail N then succeed / exhaust cleanly), INTEGRITY-REJECT-THEN-RETRY (a corrupt fragment is caught and 5// re-fetched, never stitched = no broken fragments), and resumable done-state (mark/query + file round-trip). 6// A fetch CALLBACK injects deterministic failures (rctx selects the scenario). license_tier: ORIGINAL expect_exit: 0 7import "nx_syscalls.nx" 8import "nx_robust_dl.nx" 9import "nx_gate_verdict.nx" 10 11func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw(" PASS " as *u8) } else { gw(" FAIL " as *u8) } gw(name); gw(" 12" as *u8); return ok } 13 14// fill `out` with npkts TS packets (188B each). valid=1 -> each packet starts with 0x47; valid=0 -> corrupt 15// (first byte 0x00, no sync). Returns byte count. 16func fill_ts(out: *u8, npkts: i64, valid: i64) -> i64 { 17 var i: i64 = 0 18 while i < (npkts * 188) { out[i] = 0 as u8; i = i + 1 } 19 if valid == 1 { var p: i64 = 0; while p < npkts { out[p * 188] = 0x47 as u8; p = p + 1 } } 20 return npkts * 188 21} 22// fetch callback: rctx selects the failure scenario. 23// 1 = network-fail attempts 0,1 then a GOOD fragment on attempt 2 24// 2 = always network-fail 25// 3 = a CORRUPT fragment on attempt 0 (passes network, fails integrity) then a GOOD one on attempt 1 26func gate_fetch(url: *u8, urllen: i64, attempt: i64, out: *u8, outcap: i64, rctx: i64) -> i64 { 27 if rctx == 1 { if attempt < 2 { return 0 } return fill_ts(out, 2, 1) } 28 if rctx == 2 { return 0 } 29 if rctx == 3 { if attempt == 0 { return fill_ts(out, 2, 0) } return fill_ts(out, 2, 1) } 30 return 0 31} 32 33func main() -> i64 { 34 gw("robust-dl SOVEREIGN gate (TS integrity + fragment retry + integrity-reject-retry + resume state)\n" as *u8) 35 var pass: i64 = 0 36 var ttl: i64 = 0 37 let buf: *u8 = sys_mmap(65536) 38 let url: *u8 = "https://cdn/seg.ts" as *u8 39 40 // --- integrity --- 41 fill_ts(buf, 3, 1) 42 ttl=ttl+1; pass=pass+grow("V1 valid 3-packet TS -> ok\x00" as *u8, rdl_verify_ts(buf, 3 * 188)) 43 fill_ts(buf, 2, 0) 44 ttl=ttl+1; pass=pass+grow("V2 corrupt TS (no 0x47) -> reject\x00" as *u8, (1 - rdl_verify_ts(buf, 2 * 188))) 45 fill_ts(buf, 2, 1) 46 ttl=ttl+1; pass=pass+grow("V3 truncated (not 188-aligned) -> reject\x00" as *u8, (1 - rdl_verify_ts(buf, 300))) 47 fill_ts(buf, 3, 1); buf[188] = 0x00 as u8 // break packet-2 boundary 48 ttl=ttl+1; pass=pass+grow("V4 broken mid-fragment sync -> reject\x00" as *u8, (1 - rdl_verify_ts(buf, 3 * 188))) 49 50 // --- retry --- 51 let r1: i64 = rdl_fetch_retry(url, 18, buf, 65536, RDL_TS, &gate_fetch, 1, 5, 0) 52 ttl=ttl+1; pass=pass+grow("R1 fail 2x then succeed -> 376 bytes\x00" as *u8, (r1 == 376) as i64) 53 let r2: i64 = rdl_fetch_retry(url, 18, buf, 65536, RDL_TS, &gate_fetch, 2, 5, 0) 54 ttl=ttl+1; pass=pass+grow("R2 always-fail -> -1 (exhausted, no hang)\x00" as *u8, (r2 == (0 - 1)) as i64) 55 // R3: attempt-0 fragment is CORRUPT (network-ok) -> rejected -> retried -> attempt-1 good. No broken stitch. 56 let r3: i64 = rdl_fetch_retry(url, 18, buf, 65536, RDL_TS, &gate_fetch, 3, 5, 0) 57 var r3ok: i64 = 1 58 if r3 != 376 { r3ok = 0 } 59 if rdl_verify_ts(buf, r3) == 0 { r3ok = 0 } // the returned fragment IS the good one 60 ttl=ttl+1; pass=pass+grow("R3 corrupt-then-good: rejects broken, returns whole 376\x00" as *u8, r3ok) 61 62 // --- resume state --- 63 let st: *u8 = sys_mmap(64) 64 var z: i64 = 0; while z < 64 { st[z] = 0 as u8; z = z + 1 } 65 rdl_state_mark(st, 0); rdl_state_mark(st, 2); rdl_state_mark(st, 4) 66 var s1: i64 = 1 67 if rdl_state_done(st, 0) != 1 { s1 = 0 } 68 if rdl_state_done(st, 1) != 0 { s1 = 0 } 69 if rdl_state_done(st, 2) != 1 { s1 = 0 } 70 if rdl_state_count(st, 64) != 3 { s1 = 0 } 71 ttl=ttl+1; pass=pass+grow("S1 mark 0,2,4 -> done+count correct\x00" as *u8, s1) 72 // S2: persist + reload (resume across a restart) 73 rdl_state_save("/tmp/rdl_test.state\x00" as *u8, st, 64) 74 let st2: *u8 = sys_mmap(64) 75 let rd: i64 = rdl_state_load("/tmp/rdl_test.state\x00" as *u8, st2, 64) 76 var s2: i64 = 1 77 if rd != 64 { s2 = 0 } 78 if rdl_state_done(st2, 4) != 1 { s2 = 0 } 79 if rdl_state_done(st2, 3) != 0 { s2 = 0 } 80 if rdl_state_count(st2, 64) != 3 { s2 = 0 } 81 ttl=ttl+1; pass=pass+grow("S2 save+reload -> resume state survives restart\x00" as *u8, s2) 82 83 gw("pass=" as *u8); gn(pass); gw("/" as *u8); gn(ttl); gw("\n" as *u8) 84 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check 85 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled 86 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify. 87 let ctr__dry: *i64 = gv_ctr() 88 ctr__dry[0] = pass 89 ctr__dry[1] = ttl 90 let rc__dry: i64 = gv_verdict("ROBUST-DL-GATE" as *u8, ctr__dry, "retry + integrity-reject + resume: no broken fragments, resumable)" as *u8) 91 sys_exit(rc__dry) 92 return rc__dry 93}