nx_socket_holder_observation_gate.nx source
↩ module page · 102 lines · 6776 B
1// Actual private listener/fork/fd observations. No signals, deploys or filesystem writes.
2import "nx_os_introspect.nx"
3import "nx_http_server.nx"
4import "nx_gate_verdict.nx"
5const OG_PIPE_BYTES: i64 = 8
6const OG_FD_MASK: i64 = 0xffffffff
7const OG_FD_SHIFT: i64 = 32
8const OG_PORT_MAX: i64 = 65535
9
10func og_byte(fd: i64, write: i64) -> i64 {
11 let b: *u8=sys_mmap(1)
12 if (b as i64) <= 0 { return 0-1 }
13 b[0]=1 as u8
14 var result: i64=0-1
15 if write == 1 { result=sys_write(fd,b,1) } else { result=sys_read(fd,b,1) }
16 sys_munmap(b,1)
17 if result != 1 { return 0-1 }; return 0
18}
19func og_contains(rows: *i64, count: i64, pid: i64, inode: i64) -> i64 {
20 var p: i64=0
21 while p < count {
22 let base: i64=p*PON_OBS_ROW_SLOTS
23 if rows[base+PON_OBS_PID] == pid && rows[base+PON_OBS_INODE] == inode { return 1 }
24 p=p+1
25 }; return 0
26}
27func main(argc: i64, argv: *i64) -> i64 {
28 if argc != 3 { gv_puts("usage: socket-holder-gate unused-loopback-port row-capacity\n" as *u8); return 3 }
29 let port: i64=pon_obs_uint(argv[1] as *u8,0,pon_strlen(argv[1] as *u8))
30 let capacity: i64=pon_obs_uint(argv[2] as *u8,0,pon_strlen(argv[2] as *u8))
31 if port <= 0 || port > OG_PORT_MAX || capacity <= 0 { return 3 }
32 if capacity > PON_OBS_I64_MAX/(PON_OBS_ROW_SLOTS*PON_OBS_I64_BYTES) { return 3 }
33 let ctr: *i64=gv_ctr(); gv_head("SOCKET-HOLDER-OBSERVATION / current shared owner" as *u8)
34 if sys_ignore_sigpipe() != 0 { return 3 }
35 let st: *i64=sys_mmap(PON_OBS_STATE_SLOTS*PON_OBS_I64_BYTES) as *i64
36 let rows: *i64=sys_mmap(capacity*PON_OBS_ROW_SLOTS*PON_OBS_I64_BYTES) as *i64
37 let addr: *u8=sys_mmap(16); let verdict: *i64=sys_mmap(8) as *i64
38 if (st as i64) <= 0 || (rows as i64) <= 0 || (addr as i64) <= 0 || (verdict as i64) <= 0 { return 3 }
39 gv_check("strict socket parser rejects malformed identity" as *u8,pon_obs_socket_inode("socket:[12x]" as *u8,12) < 0,ctr)
40 gv_check("socket parser distinguishes unrelated link" as *u8,pon_obs_socket_inode("anon_inode:[eventfd]" as *u8,19) == 0,ctr)
41 gv_check("invalid inode is structured bad input" as *u8,pon_observe_inode(0,rows,capacity,st) == PON_OBS_BAD_INPUT,ctr)
42 nx_http_server_addr_loopback(addr,port)
43 let lfd: i64=nx_http_server_listen(addr,1,verdict)
44 gv_check("actual private listener bound" as *u8,lfd >= 0,ctr)
45 if lfd < 0 { return gv_verdict("SOCKET-HOLDER-OBSERVATION" as *u8,ctr,"port unavailable; no service was stopped" as *u8) }
46 let path: *u8=sys_mmap(SYS_PATH_MAX); let link: *u8=sys_mmap(SYS_PATH_MAX)
47 if (path as i64) <= 0 || (link as i64) <= 0 { sys_close(lfd); return 3 }
48 let prefix: *u8="/proc/self/fd/" as *u8
49 var q: i64=0; while prefix[q] != (0 as u8) { path[q]=prefix[q]; q=q+1 }
50 pon_obs_number(path,q,lfd)
51 let ln: i64=sys_readlinkat(path,link,SYS_PATH_MAX)
52 var inode: i64=0
53 if ln > 0 && ln < SYS_PATH_MAX { inode=pon_obs_socket_inode(link,ln) }
54 gv_check("real listener inode obtained from owned fd" as *u8,inode > 0,ctr)
55 if inode <= 0 { sys_close(lfd); return gv_verdict("SOCKET-HOLDER-OBSERVATION" as *u8,ctr,"native readlink contract failed" as *u8) }
56 let ready: *i64=sys_mmap(OG_PIPE_BYTES) as *i64
57 let release: *i64=sys_mmap(OG_PIPE_BYTES) as *i64
58 if (ready as i64) <= 0 || (release as i64) <= 0 { sys_close(lfd); return 3 }
59 if sys_pipe2(ready,0) != 0 { sys_close(lfd); return 3 }
60 let rr: i64=ready[0] & OG_FD_MASK; let rw: i64=(ready[0] >> OG_FD_SHIFT) & OG_FD_MASK
61 if sys_pipe2(release,0) != 0 { sys_close(rr); sys_close(rw); sys_close(lfd); return 3 }
62 let qr: i64=release[0] & OG_FD_MASK; let qw: i64=(release[0] >> OG_FD_SHIFT) & OG_FD_MASK
63 let pid: i64=sys_fork()
64 if pid < 0 { sys_close(rr); sys_close(rw); sys_close(qr); sys_close(qw); sys_close(lfd); return 3 }
65 if pid == 0 {
66 sys_close(rr); sys_close(qw)
67 if og_byte(rw,1) != 0 { sys_exit_group(3) }
68 if og_byte(qr,0) != 0 { sys_exit_group(3) }
69 let closed: i64=sys_close(lfd)
70 if closed != 0 { sys_exit_group(3) }
71 if og_byte(rw,1) != 0 { sys_exit_group(3) }
72 if og_byte(qr,0) != 0 { sys_exit_group(3) }
73 sys_close(qr); sys_close(rw); sys_exit_group(0)
74 }
75 sys_close(rw); sys_close(qr)
76 gv_check("owned child ready with inherited listener" as *u8,og_byte(rr,0) == 0,ctr)
77 pon_obs_init(st)
78 let held: i64=pon_observe_pid_inode(pid,inode,rows,capacity,st)
79 gv_check("owned PID fd traversal complete" as *u8,held == PON_OBS_COMPLETE,ctr)
80 gv_check("inherited child holder retained" as *u8,og_contains(rows,st[PON_OBS_STORED],pid,inode),ctr)
81 pon_obs_init(st)
82 let cap_rc: i64=pon_observe_pid_inode(pid,inode,0 as *i64,0,st)
83 gv_check("zero capacity refuses a real matching holder" as *u8,cap_rc == PON_OBS_CAPACITY && st[PON_OBS_MATCHES] > 0 && st[PON_OBS_STORED] == 0,ctr)
84 let all_rc: i64=pon_observe_inode(inode,rows,capacity,st)
85 gv_check("full proc census retains owned child or reports explicit capacity" as *u8,og_contains(rows,st[PON_OBS_STORED],pid,inode) == 1 || all_rc == PON_OBS_CAPACITY,ctr)
86 gv_check("global census does not discard uncertainty" as *u8,(all_rc == PON_OBS_COMPLETE && st[PON_OBS_ERRORS] == 0) || (all_rc == PON_OBS_UNKNOWN && st[PON_OBS_ERRORS] > 0) || all_rc == PON_OBS_CAPACITY,ctr)
87 gv_puts("global_state=" as *u8); gv_num(all_rc); gv_puts(" pids=" as *u8); gv_num(st[PON_OBS_PIDS]); gv_puts(" matches=" as *u8); gv_num(st[PON_OBS_MATCHES]); gv_puts(" stored=" as *u8); gv_num(st[PON_OBS_STORED]); gv_puts(" unresolved=" as *u8); gv_num(st[PON_OBS_ERRORS]); gv_puts(" first_error=" as *u8); gv_num(st[PON_OBS_FIRST_ERROR]); gv_puts("\n" as *u8)
88 gv_check("owned child released to close listener" as *u8,og_byte(qw,1) == 0,ctr)
89 gv_check("owned child confirms actual close" as *u8,og_byte(rr,0) == 0,ctr)
90 pon_obs_init(st)
91 let absent: i64=pon_observe_pid_inode(pid,inode,rows,capacity,st)
92 gv_check("same live child is no longer a holder after close" as *u8,absent == PON_OBS_COMPLETE && st[PON_OBS_MATCHES] == 0,ctr)
93 gv_check("owned child released to exit" as *u8,og_byte(qw,1) == 0,ctr)
94 sys_close(rr); sys_close(qw)
95 let waited: i64=sys_wait4(pid,verdict,0)
96 gv_check("owned child actually reaped normally" as *u8,waited == pid && verdict[0] == 0,ctr)
97 pon_obs_init(st)
98 let gone: i64=pon_observe_pid_inode(pid,inode,rows,capacity,st)
99 gv_check("vanished PID is unknown rather than certified absence" as *u8,gone == PON_OBS_UNKNOWN && st[PON_OBS_ERRORS] > 0,ctr)
100 gv_check("owned parent listener closed" as *u8,sys_close(lfd) == 0,ctr)
101 return gv_verdict("SOCKET-HOLDER-OBSERVATION" as *u8,ctr,"inode FD references only; complete traversal is not atomic snapshot or stable process identity" as *u8)
102}