code wiki / _hdl_build / nx_signaling_v2_cascade_gate.nx
nx_signaling_v2_cascade_gate.nx source
↩ module page · 132 lines · 7056 B
1import "nx_gate_base.nx"
2// nx_signaling_v2_cascade_gate.nx -- OCTO-CLASS CASCADE proof: two relay instances (HOME + EDGE) peered
3// over the sovereign UDP plane. A native UDP client on EDGE and one on HOME. A frame sent on EDGE reaches
4// the HOME client (crossed the inter-relay link) and vice-versa, and split-horizon means it crosses each
5// link EXACTLY ONCE (no loop, no duplicate). This is the structural WAN fix: bandwidth O(relays) not
6// O(peers). NISHI all the way (two nx daemons, sovereign dgram wire). license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_dgram_media.nx"
9
10const CG_JOIN: i64 = 0x4A
11const CG_ACK: i64 = 0x4B
12const CG_ROOMFRAME: i64 = 0x4D
13
14func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw(" PASS " as *u8) } else { gw(" FAIL " as *u8) } gw(name); gw("
15" as *u8); return ok }
16func gn(v: i64) -> i64 {
17 let b: *u8=sys_mmap(28); var m: i64=v; if m<0{sys_write(1,"-" as *u8,1);m=0-m}
18 let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1} while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}
19 var i: i64=0; while i<k{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 }
20func ck(name: *u8, ok: i64, p: *i64, t: *i64) -> i64 {
21 t[0]=t[0]+1; gw(" " as *u8); gw(name)
22 if ok==1 { gw(" PASS\n" as *u8); p[0]=p[0]+1 } else { gw(" FAIL\n" as *u8) }
23 return 0 }
24
25func cg_addr(a: *u8, port: i64) -> i64 {
26 a[0]=2 as u8; a[1]=0 as u8
27 a[2]=((port>>8)&0xff) as u8; a[3]=(port&0xff) as u8
28 a[4]=127 as u8; a[5]=0 as u8; a[6]=0 as u8; a[7]=1 as u8
29 var i: i64=8; while i<16 { a[i]=0 as u8; i=i+1 } return 0 }
30func cg_tmo(fd: i64, sec: i64, usec: i64) -> i64 {
31 let tv: *i64 = sys_mmap(16) as *i64; tv[0]=sec; tv[1]=usec
32 sys_setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, tv as *u8, 16); return 0 }
33func cg_join(fd: i64, raddr: *u8, id: *u8, room: *u8, rlen: i64) -> i64 {
34 let pk: *u8 = sys_mmap(4096); let rx: *u8 = sys_mmap(2048); let info: *i64 = sys_mmap(8*12) as *i64
35 if dgm_pack_frame(CG_JOIN, id, 0, room, rlen, pk, 4096) != 1 { return 0 }
36 let pl: i64 = (pk[0]&0xff)+((pk[1]&0xff)<<8)
37 sys_sendto(fd, ((pk as i64)+2) as *u8, pl, 0, raddr, 16)
38 cg_tmo(fd, 2, 0)
39 let fl: *i64 = sys_mmap(16) as *i64; fl[0]=16; let src: *u8 = sys_mmap(16)
40 let r: i64 = sys_recvfrom(fd, rx, 2048, 0, src, fl)
41 if r <= 0 { return 0 }
42 if dgm_parse_pkt(rx, r, info) != 0 { return 0 }
43 if info[0] != CG_ACK { return 0 }
44 return 1 }
45func cg_send(fd: i64, raddr: *u8, id: *u8, seq: i64, body: *u8, blen: i64) -> i64 {
46 let pk: *u8 = sys_mmap(8192)
47 if dgm_pack_frame(CG_ROOMFRAME, id, seq, body, blen, pk, 8192) != 1 { return 0 }
48 let pl: i64 = (pk[0]&0xff)+((pk[1]&0xff)<<8)
49 sys_sendto(fd, ((pk as i64)+2) as *u8, pl, 0, raddr, 16)
50 return 1 }
51// recv one datagram, reassemble; returns payload len (fout filled) or -1 (timeout). info[0]=kind.
52func cg_recv(fd: i64, rxm: *u8, fout: *u8, info: *i64) -> i64 {
53 let rb: *u8 = sys_mmap(2048); let fl: *i64 = sys_mmap(16) as *i64; fl[0]=16; let src: *u8 = sys_mmap(16)
54 let r: i64 = sys_recvfrom(fd, rb, 2048, 0, src, fl)
55 if r <= 0 { return 0 - 1 }
56 return dgm_rx_add(rxm, rb, r, fout, 65536, info) }
57
58func cg_spawn(dpath: *u8, av: *i64) -> i64 {
59 let pid: i64 = sys_fork()
60 if pid == 0 {
61 let ev: *i64 = sys_mmap(16) as *i64; ev[0]=0
62 sys_execve(dpath, av, ev); sys_exit(127)
63 }
64 return pid }
65
66func main() -> i64 {
67 gw("=== nx_signaling_v2 CASCADE gate (Octo-class: HOME + EDGE, frame crosses the link ONCE) ===\n" as *u8)
68 let p: *i64 = sys_mmap(16) as *i64; let t: *i64 = sys_mmap(16) as *i64
69 var dpath: *u8 = "/tmp/nx_signaling_v2.sov.elf" as *u8
70 let probe: i64 = sys_openat_rd(dpath)
71 if probe >= 0 { sys_close(probe) } else { dpath = "/tmp/nx_signaling_v2.elf" as *u8 }
72
73 // HOME: wss 8446 / udp 8472 (avoid the live-gate 8445/8471); no cascade
74 let avh: *i64 = sys_mmap(80) as *i64
75 avh[0]=dpath as i64; avh[1]="/tmp/cg_none1\x00" as *u8 as i64; avh[2]="/tmp/cg_none2\x00" as *u8 as i64
76 avh[3]="8446\x00" as *u8 as i64; avh[4]="8472\x00" as *u8 as i64; avh[5]=0
77 let ph: i64 = cg_spawn(dpath, avh)
78 // EDGE: wss 8456 / udp 8482 ; cascade -> 127.0.0.1:8472 room "casc"
79 let ave: *i64 = sys_mmap(80) as *i64
80 ave[0]=dpath as i64; ave[1]="/tmp/cg_none1\x00" as *u8 as i64; ave[2]="/tmp/cg_none2\x00" as *u8 as i64
81 ave[3]="8456\x00" as *u8 as i64; ave[4]="8482\x00" as *u8 as i64
82 ave[5]="127.0.0.1\x00" as *u8 as i64; ave[6]="8472\x00" as *u8 as i64; ave[7]="casc\x00" as *u8 as i64; ave[8]=0
83 let pe: i64 = cg_spawn(dpath, ave)
84 sys_sleep_ms(500) // daemons bind + EDGE fires its startup CASCADE-JOIN to HOME
85
86 let homea: *u8 = sys_mmap(16); cg_addr(homea, 8472)
87 let edgea: *u8 = sys_mmap(16); cg_addr(edgea, 8482)
88 let room: *u8 = "casc" as *u8
89
90 // Hc joins HOME, Ec joins EDGE (both room "casc")
91 let hc: i64 = sys_socket(AF_INET, SOCK_DGRAM, 0)
92 let ec: i64 = sys_socket(AF_INET, SOCK_DGRAM, 0)
93 var joined: i64 = 0
94 if cg_join(hc, homea, "HC000000" as *u8, room, 4) == 1 { if cg_join(ec, edgea, "EC000000" as *u8, room, 4) == 1 { joined = 1 } }
95 ck("cascade: HOME + EDGE up, Hc & Ec joined room casc\x00" as *u8, joined, p, t)
96
97 let rxh: *u8 = sys_mmap(DGM_RX_REGION); dgm_rx_init(rxh)
98 let rxe: *u8 = sys_mmap(DGM_RX_REGION); dgm_rx_init(rxe)
99 let fout: *u8 = sys_mmap(65536); let info: *i64 = sys_mmap(8*12) as *i64
100 sys_sleep_ms(200) // let HOME register EDGE's CASCADE-JOIN
101
102 // T1 EDGE -> HOME: Ec sends; the frame must reach Hc (crossed EDGE->HOME cascade link)
103 let body: *u8 = sys_mmap(64)
104 var bi: i64=0; while bi<40 { body[bi]=((bi*9+3)&255) as u8; bi=bi+1 }
105 cg_send(ec, edgea, "EC000000" as *u8, 1, body, 40)
106 cg_tmo(hc, 2, 0)
107 let n1: i64 = cg_recv(hc, rxh, fout, info)
108 var t1: i64 = 1
109 if n1 != 40 { t1 = 0 } else { var q: i64=0; while q<40 { if fout[q] != body[q] { t1=0; q=40 } else { q=q+1 } } }
110 ck("T1 EDGE-client frame reaches HOME-client (link crossed)\x00" as *u8, t1, p, t)
111
112 // T2 split-horizon: Hc must get EXACTLY ONE copy (no loop bounced it back). A 2nd recv must time out.
113 cg_tmo(hc, 1, 0)
114 let n1b: i64 = cg_recv(hc, rxh, fout, info)
115 var t2: i64 = 0
116 if n1b <= 0 { t2 = 1 }
117 ck("T2 split-horizon: no duplicate/loop of the crossed frame\x00" as *u8, t2, p, t)
118
119 // T3 HOME -> EDGE: Hc sends; Ec must receive (reverse crossing)
120 var bj: i64=0; while bj<36 { body[bj]=((bj*7+11)&255) as u8; bj=bj+1 }
121 cg_send(hc, homea, "HC000000" as *u8, 1, body, 36)
122 cg_tmo(ec, 2, 0)
123 let n2: i64 = cg_recv(ec, rxe, fout, info)
124 var t3: i64 = 1
125 if n2 != 36 { t3 = 0 } else { var q2: i64=0; while q2<36 { if fout[q2] != body[q2] { t3=0; q2=36 } else { q2=q2+1 } } }
126 ck("T3 HOME-client frame reaches EDGE-client (reverse)\x00" as *u8, t3, p, t)
127
128 nx_kill(ph, 9); nx_kill(pe, 9)
129 gw("CASCADE: " as *u8); gn(p[0]); gw("/" as *u8); gn(t[0])
130 if p[0]==t[0] { gw(" ALL GREEN -- Octo-class relay-to-relay cascade proven\n" as *u8); return 0 }
131 gw(" RED\n" as *u8)
132 return 1 }