nx_compare_capture_integration_gate.nx source
↩ module page · 246 lines · 13715 B
1// Source-only reusable Compare capture integration. Actual wrapper, finite native witness.
2// All authority files and executable copies are confined to a fresh private fixture tree.
3import "nx_syscalls.nx"
4import "nx_gate_verdict.nx"
5import "nx_tool_run.nx"
6import "nx_build_canon_input_lib.nx"
7import "nx_rank_refresh_lib.nx"
8const MODE_0755: i64 = 493
9const RIG_PATH: i64 = 4096
10const RIG_PTR: i64 = 8
11const RIG_FILE_MODE: i64 = 384
12const RIG_DIR_MODE: i64 = 448
13const RIG_EINVAL: i64 = 0 - 22
14const RIG_SETUP: i64 = 90
15const RIG_GUARD: *u8 = "NISHI-COMPARE-CAPTURE-FIXTURE\n"
16const CRG_EXCLUSIVE: i64 = 2
17const CRG_UNLOCK: i64 = 8
18const CRG_ROLES: i64 = 4
19const CRG_SLOW: i64 = 0
20const CRG_ESSENTIAL: i64 = 1
21const CRG_ORDINARY: i64 = 2
22const CRG_WINDOW: i64 = 3
23const CRG_START: i64 = 1
24const CRG_END: i64 = 0
25const CRG_MS_PER_SEC: i64 = 1000
26const CRG_MIN_COMPLETIONS: i64 = 2
27const CRG_FAULT_ROLE: i64 = 4
28const CRG_FAULT_POINT: i64 = 2
29const CRG_TEST_ECHILD: i64 = 0 - 10
30func rig_len(p: *u8) -> i64 { var n: i64 = 0; while p[n] != (0 as u8) { n = n + 1 } return n }
31func rig_eq(a: *u8, b: *u8) -> i64 {
32 var i: i64 = 0
33 while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 }
34 if b[i] != (0 as u8) { return 0 }
35 return 1
36}
37func rig_num(p: *u8) -> i64 {
38 let n: i64 = rig_len(p)
39 if n == 0 { return 0 - 1 }
40 var i: i64 = 0; var v: i64 = 0
41 while i < n {
42 let c: i64 = p[i] as i64
43 if c < BCI_ZERO { return 0 - 1 }
44 if c > BCI_NINE { return 0 - 1 }
45 let d: i64 = c - BCI_ZERO
46 if v > (BCI_I64_MAX-d)/BCI_DECIMAL_BASE { return 0 - 1 }
47 v = v*BCI_DECIMAL_BASE+d; i = i + 1
48 }
49 return v
50}
51func rig_join(root: *u8, rel: *u8) -> *u8 {
52 if rig_len(root)+rig_len(rel)+2 > RIG_PATH { return 0 as *u8 }
53 let p: *u8 = sys_mmap(RIG_PATH)
54 var o: i64 = gv_cat(p, 0, root)
55 o = gv_cat(p, o, "/" as *u8); o = gv_cat(p, o, rel); p[o] = 0 as u8
56 return p
57}
58func rig_exists(path: *u8) -> i64 {
59 if (path as i64) == 0 { return 0 }
60 let f: i64 = sys_openat_rd(path)
61 if f < 0 { return 0 }
62 sys_close(f); return 1
63}
64// Reject symlinks in every supplied parent component. No descendant is reused.
65func rig_parent(path: *u8) -> i64 {
66 let n: i64 = rig_len(path)
67 if n <= 1 { return 0 }
68 if n >= RIG_PATH { return 0 }
69 if path[0] != (BCI_SLASH as u8) { return 0 }
70 if bci_relative_path(path, 1, n-1, RIG_PATH-2) != 1 { return 0 }
71 let part: *u8 = sys_mmap(RIG_PATH)
72 let probe: *u8 = sys_mmap(RIG_PATH)
73 var i: i64 = 0
74 while i <= n {
75 var edge: i64 = 0
76 if i == n { edge = 1 } else { if i > 0 { if path[i] == (BCI_SLASH as u8) { edge = 1 } } }
77 if edge == 1 {
78 part[i] = 0 as u8
79 if sys_readlinkat(part, probe, RIG_PATH) != RIG_EINVAL { return 0 }
80 }
81 if i < n { part[i] = path[i] }
82 i = i + 1
83 }
84 return 1
85}
86func rig_write(path: *u8, buf: *u8, n: i64) -> i64 {
87 if (path as i64) == 0 { return 0 }
88 let fd: i64 = sys_openat_wr(path, RIG_FILE_MODE)
89 if fd < 0 { return 0 }
90 var w: i64 = 0
91 while w < n {
92 let got: i64 = sys_write(fd, (buf as i64+w) as *u8, n-w)
93 if got <= 0 { sys_close(fd); return 0 }
94 w = w + got
95 }
96 // Fixture visibility check only; persistence barriers belong to the subject under test.
97 let close: i64 = sys_close(fd)
98 if close != 0 { return 0 }
99 return rrf_file_equal(path, buf, n)
100}
101func rig_file(root: *u8, rel: *u8, val: *u8) -> i64 { return rig_write(rig_join(root,rel),val,rig_len(val)) }
102func rig_dir(root: *u8, rel: *u8) -> i64 {
103 let p: *u8 = rig_join(root, rel)
104 if (p as i64) == 0 { return 0 }
105 if sys_mkdir(p,RIG_DIR_MODE) != 0 { return 0 }
106 return 1
107}
108func rig_link(root: *u8, rel: *u8, target: *u8) -> i64 {
109 let p: *u8 = rig_join(root,rel)
110 if (p as i64) == 0 { return 0 }
111 if sys_symlinkat(target,p) != 0 { return 0 }
112 return 1
113}
114func rig_guard() -> i64 { return rrf_file_equal("fixture-root.guard" as *u8,RIG_GUARD,rig_len(RIG_GUARD)) }
115
116
117func cci_copy(root: *u8,rel: *u8,source: *u8) -> i64 {
118 let n: *i64=sys_mmap(8) as *i64; let b: *u8=sys_read_file(source,n)
119 if (b as i64)==0 { return 0 }; if n[0]<=0 { return 0 }
120 let dest: *u8=rig_join(root,rel)
121 if rig_write(dest,b,n[0])!=1 { return 0 }
122 if sys_fchmodat(dest,MODE_0755)!=0 { return 0 }
123 return 1
124}
125func cci_emit(p: *u8,n: i64) -> i64 {
126 var done: i64=0
127 while done<n { let w: i64=sys_write(1,(p as i64+done) as *u8,n-done); if w<=0 { return 0 }; done=done+w }
128 return 1
129}
130// Only this finite native witness is placed at the fixture's authorized renderer path.
131func cci_child(argc: i64,argv: *i64) -> i64 {
132 if argc!=3 { return RIG_SETUP }; if rig_guard()!=1 { return RIG_SETUP }
133 let mode: *u8=argv[2] as *u8
134 if rig_eq(mode,"json" as *u8)!=1 { if rig_eq(mode,"html" as *u8)!=1 { return RIG_SETUP } }
135 let args: *u8=sys_mmap(RIG_PATH)
136 var n: i64=gv_cat(args,0,argv[1] as *u8); n=gv_cat(args,n,"\t" as *u8); n=gv_cat(args,n,mode); n=gv_cat(args,n,"\n" as *u8)
137 if rig_write("dispatch.argv" as *u8,args,n)!=1 { return RIG_SETUP }
138 let lp: *i64=sys_mmap(8) as *i64; let action: *u8=sys_read_file("fixture.action" as *u8,lp)
139 if (action as i64)==0 { return RIG_SETUP }
140 if rig_eq(action,"cut" as *u8)==1 {
141 let sz: *u8=sys_read_file("fixture.cap" as *u8,lp); if (sz as i64)==0 { return RIG_SETUP }
142 let cap: i64=rig_num(sz); if cap<=0 { return RIG_SETUP }; if cap>=BCI_I64_MAX { return RIG_SETUP }
143 let b: *u8=sys_mmap(cap+1); var i: i64=0; while i<cap+1 { b[i]=120 as u8; i=i+1 }
144 if cci_emit(b,cap+1)!=1 { return RIG_SETUP }
145 } else {
146 var output: *u8="{\"fixture\":true}\n" as *u8
147 if rig_eq(mode,"html" as *u8)==1 { output="<html><body>fixture</body></html>\n" as *u8 }
148 if cci_emit(output,rig_len(output))!=1 { return RIG_SETUP }
149 }
150 if rig_eq(action,"nonzero" as *u8)==1 { return 9 }
151 return 0
152}
153func cci_contains(buf: *u8,n: i64,s: *u8) -> i64 { return tr_contains(buf,n,s) }
154func main(argc: i64,argv: *i64) -> i64 {
155 if argc==3 { return cci_child(argc,argv) }
156 if argc!=8 { gv_puts("usage: SELF WRAPPER PRIVATE_PARENT CASE CAPTURE_BYTES CHILD_TIMEOUT_MS OUTER_CAPTURE_TIMEOUT_MS\n" as *u8); return RIG_SETUP }
157 let self: *u8=argv[1] as *u8; let wrapper: *u8=argv[2] as *u8; let parent: *u8=argv[3] as *u8; let which: *u8=argv[4] as *u8
158 if rig_parent(self)!=1 { return RIG_SETUP }; if rig_parent(wrapper)!=1 { return RIG_SETUP }; if rig_parent(parent)!=1 { return RIG_SETUP }
159 let capacity: i64=rig_num(argv[5] as *u8); let timeout: i64=rig_num(argv[6] as *u8); let outer: i64=rig_num(argv[7] as *u8)
160 if capacity<RIG_PATH { return RIG_SETUP }; if capacity>=BCI_I64_MAX { return RIG_SETUP }
161 if timeout<=0 { return RIG_SETUP }; if outer<=timeout { return RIG_SETUP }
162 var known: i64=0
163 if rig_eq(which,"json" as *u8)==1 { known=1 }; if rig_eq(which,"html" as *u8)==1 { known=1 }
164 if rig_eq(which,"planless" as *u8)==1 { known=1 }; if rig_eq(which,"legacy" as *u8)==1 { known=1 }
165 if rig_eq(which,"missing-policy" as *u8)==1 { known=1 }; if rig_eq(which,"wrong-hash" as *u8)==1 { known=1 }
166 if rig_eq(which,"missing-hash" as *u8)==1 { known=1 }
167 if rig_eq(which,"changed-binary" as *u8)==1 { known=1 }; if rig_eq(which,"nonzero" as *u8)==1 { known=1 }
168 if rig_eq(which,"truncation" as *u8)==1 { known=1 }; if known!=1 { return RIG_SETUP }
169 let leaf: *u8=sys_mmap(RIG_PATH); var k: i64=gv_cat(leaf,0,"compare-capture-" as *u8); k=gv_catn(leaf,k,sys_now_ms()); leaf[k]=0 as u8
170 let root: *u8=rig_join(parent,leaf)
171 if sys_mkdir(root,RIG_DIR_MODE)!=0 { return RIG_SETUP }
172 if rig_dir(root,"buildroot" as *u8)!=1 { return RIG_SETUP }
173 if rig_dir(root,"buildroot/_build" as *u8)!=1 { return RIG_SETUP }
174 if rig_dir(root,"buildroot/knowledge" as *u8)!=1 { return RIG_SETUP }
175 if rig_dir(root,"buildroot/knowledge/status" as *u8)!=1 { return RIG_SETUP }
176 if rig_dir(root,"buildroot/knowledge/compare" as *u8)!=1 { return RIG_SETUP }
177 if rig_dir(root,"knowledge" as *u8)!=1 { return RIG_SETUP }
178 if rig_dir(root,"knowledge/status" as *u8)!=1 { return RIG_SETUP }
179 if rig_file(root,"fixture-root.guard" as *u8,RIG_GUARD)!=1 { return RIG_SETUP }
180 if rig_file(root,"buildroot/fixture-root.guard" as *u8,RIG_GUARD)!=1 { return RIG_SETUP }
181 if cci_copy(root,"wrapper.elf" as *u8,wrapper)!=1 { return RIG_SETUP }
182 let target: *u8="nx_swcompare_matrix_ladder_test_20260907" as *u8
183 let renderer: *u8=rig_join(root,"buildroot/_build/nx_swcompare_matrix_ladder_test_20260907.sov.elf" as *u8)
184 if cci_copy(root,"buildroot/_build/nx_swcompare_matrix_ladder_test_20260907.sov.elf" as *u8,self)!=1 { return RIG_SETUP }
185 let lp: *i64=sys_mmap(8) as *i64; let binary: *u8=sys_read_file(renderer,lp); if (binary as i64)==0 { return RIG_SETUP }
186 let digest: *u8=sys_mmap(RRF_HEX_BYTES+1); if rrf_hash(binary,lp[0],digest)!=0 { return RIG_SETUP }
187 if rig_eq(which,"wrong-hash" as *u8)==1 { if digest[0]==(48 as u8) { digest[0]=49 as u8 } else { digest[0]=48 as u8 } }
188 if rig_eq(which,"missing-hash" as *u8)==1 { digest[0]=0 as u8 }
189 var mode: *u8="json" as *u8; if rig_eq(which,"html" as *u8)==1 { mode="html" as *u8 }
190 var domain: *u8="deploy" as *u8; if rig_eq(which,"planless" as *u8)==1 { domain="fixture-planless" as *u8 }
191 let policy: *u8=sys_mmap(RIG_PATH)
192 var p: i64=gv_cat(policy,0,"fixture-scope\t" as *u8); p=gv_cat(policy,p,target); p=gv_cat(policy,p,"\t" as *u8)
193 p=gv_cat(policy,p,domain); p=gv_cat(policy,p,"\t" as *u8); p=gv_cat(policy,p,mode); p=gv_cat(policy,p,"\t" as *u8)
194 p=gv_cat(policy,p,digest); p=gv_cat(policy,p,"\n" as *u8)
195 if rig_eq(which,"missing-policy" as *u8)!=1 { if rig_write(rig_join(root,"buildroot/knowledge/compare/capture.scope" as *u8),policy,p)!=1 { return RIG_SETUP } }
196 if rig_eq(which,"changed-binary" as *u8)==1 {
197 // Append to this private copy only, after the original digest was put into the scope.
198 let fd: i64=sys_openat_append(renderer,RIG_FILE_MODE); if fd<0 { return RIG_SETUP }
199 if sys_write(fd,"x" as *u8,1)!=1 { sys_close(fd); return RIG_SETUP }; if sys_close(fd)!=0 { return RIG_SETUP }
200 }
201 var action: *u8="good" as *u8
202 if rig_eq(which,"nonzero" as *u8)==1 { action="nonzero" as *u8 }
203 if rig_eq(which,"truncation" as *u8)==1 { action="cut" as *u8 }
204 if rig_file(root,"buildroot/fixture.action" as *u8,action)!=1 { return RIG_SETUP }
205 if rig_file(root,"buildroot/fixture.cap" as *u8,argv[5] as *u8)!=1 { return RIG_SETUP }
206 let av: *i64=sys_mmap(9*RIG_PTR) as *i64
207 let subject: *u8=rig_join(root,"wrapper.elf" as *u8)
208 av[0]=subject as i64; av[1]="result" as i64; av[2]=argv[5]; av[3]=argv[6]; av[4]=mode as i64
209 if rig_eq(which,"legacy" as *u8)==1 { av[5]=0 }
210 else { av[5]=target as i64; av[6]=domain as i64; av[7]="fixture-scope" as i64; av[8]=0 }
211 if sys_chdir(root)!=0 { return RIG_SETUP }
212 let ctr: *i64=gv_ctr(); let output: *u8=sys_mmap(capacity); let olen: *i64=sys_mmap(8) as *i64
213 gv_puts("fixture_root=" as *u8); gv_puts(root); gv_puts("\n" as *u8)
214 let rc: i64=tr_run_capture_cwd(subject,av,output,capacity,olen,outer,root)
215 gv_puts("wrapper_rc=" as *u8); gv_num(rc); gv_puts("\n" as *u8)
216 gv_check("wrapper capture not full" as *u8,(olen[0]<capacity) as i64,ctr)
217 gv_check("wrapper output persisted" as *u8,rig_write("wrapper.out" as *u8,output,olen[0]),ctr)
218 var expected: i64=0; var dispatched: i64=1
219 if rig_eq(which,"missing-policy" as *u8)==1 { expected=7; dispatched=0 }
220 if rig_eq(which,"missing-hash" as *u8)==1 { expected=7; dispatched=0 }
221 if rig_eq(which,"wrong-hash" as *u8)==1 { expected=7; dispatched=0 }
222 if rig_eq(which,"changed-binary" as *u8)==1 { expected=7; dispatched=0 }
223 if rig_eq(which,"nonzero" as *u8)==1 { expected=4 }
224 if rig_eq(which,"truncation" as *u8)==1 { expected=4 }
225 gv_check("exact wrapper result" as *u8,(rc==expected) as i64,ctr)
226 let witness: *u8="buildroot/dispatch.argv" as *u8
227 if dispatched==0 { gv_check("authority refusal before dispatch" as *u8,(rig_exists(witness)==0) as i64,ctr) }
228 else {
229 let exact: *u8=sys_mmap(RIG_PATH); var z: i64=gv_cat(exact,0,domain); z=gv_cat(exact,z,"\t" as *u8); z=gv_cat(exact,z,mode); z=gv_cat(exact,z,"\n" as *u8)
230 gv_check("exact dispatched argv domain and mode" as *u8,rrf_file_equal(witness,exact,z),ctr)
231 }
232 var artifact: *u8="buildroot/knowledge/status/result.json" as *u8
233 if rig_eq(mode,"html" as *u8)==1 { artifact="buildroot/knowledge/status/result.html" as *u8 }
234 if expected==0 {
235 var wanted: *u8="{\"fixture\":true}\n" as *u8
236 if rig_eq(mode,"html" as *u8)==1 { wanted="<html><body>fixture</body></html>\n" as *u8 }
237 gv_check("exact successful artifact bytes" as *u8,rrf_file_equal(artifact,wanted,rig_len(wanted)),ctr)
238 gv_check("verified artifact receipt" as *u8,cci_contains(output,olen[0],"CAPTURE-VERIFIED" as *u8),ctr)
239 } else {
240 gv_check("no successful artifact on refusal or child failure" as *u8,(rig_exists(artifact)==0) as i64,ctr)
241 gv_check("no false verified receipt" as *u8,(cci_contains(output,olen[0],"CAPTURE-VERIFIED" as *u8)==0) as i64,ctr)
242 }
243 if rig_eq(which,"nonzero" as *u8)==1 { gv_check("child nonzero exposed" as *u8,cci_contains(output,olen[0],"child_rc=9" as *u8),ctr) }
244 if rig_eq(which,"truncation" as *u8)==1 { gv_check("truncation exposed" as *u8,cci_contains(output,olen[0],"truncated=1" as *u8),ctr) }
245 return gv_verdict("COMPARE-CAPTURE-INTEGRATION",ctr,"finite native witness; private tree; timeout never a passing outcome" as *u8)
246}