code wiki / _hdl_build / nx_cron_reconcile.nx
`nx_cron_reconcile.nx` source

↩ module page · 227 lines · 10129 B
1// nx_cron_reconcile.nx -- SOVEREIGN crontab reconciler (operator directive 2026-07-16: "make the
2// capabilities native to the nishi ecosystem, don't make me do it"). The nishi-managed block of a crontab
3// becomes DATA: cron.reg declares exactly the nishi rows that must exist; this organ rewrites the crontab
4// so its nishi rows (any line containing /nishihost/) equal EXACTLY the declared set, leaving every
5// non-nishi row BYTE-EXACT. Dead rows (retired reconcilers) vanish by construction; new rows = a registry
6// line. Runs as root with ZERO operator action by piggybacking on the existing root cron row
7// (nx_edge443_reconcile.sh -- the same proven pattern as the vsz_watchdog on the rail).
8//
9// NEVER-BRICK BY CONSTRUCTION (this writes a root-owned BOOT FILE):
10//   R1 only lines containing /nishihost/ are ever touched -- the filter IS the blast-radius bound
11//   R2 refuse (exit 3, no write) if the registry is missing/empty -- an absent SSOT must never wipe rows
12//   R3 refuse (exit 5, no write) if ANY declared row lacks /nishihost/ -- the organ cannot inject
13//      non-nishi rows even if the registry is corrupted/hostile
14//   R4 refuse (exit 4, no write) if the crontab is unreadable or EMPTY -- a boot file is never empty
15//   R5 idempotent: byte-identical result -> NO-CHANGE, zero writes (safe at any frequency)
16//   R6 atomic: write <crontab>.nxnew then renameat over -- no torn boot file ever exists on disk
17// After a real change, SIGHUP every `crond` (reload -- standard, non-destructive; if crond ignores it,
18// stale in-memory entries keep harmlessly firing removed paths until its next restart = no regression).
19//
20// usage: nx_cron_reconcile <crontab-path> <reg-path>     (gate runs it on COPIES; prod = /etc/crontab)
21// exit: 0 ok (CHANGED or NO-CHANGE) | 2 usage | 3 reg-refuse | 4 crontab-refuse | 5 reg-taint | 6 write-fail
22// license_tier: ORIGINAL   module: nishi-core.ops.cron_reconcile
23import "nx_syscalls.nx"
24const CR_MAGIC_65536: i64 = 65536
25
26const CR_CTCAP:  i64 = 65536
27const CR_REGCAP: i64 = 16384
28const CR_MARK:   *u8 = "/nishihost/" as *u8
29
30func cr_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
31func cr_p(s: *u8) -> i64 { sys_write(1, s, cr_slen(s)); return 0 }
32func cr_decw(v: i64, out: *u8) -> i64 {
  var o: i64 = 0
  var m: i64 = v
  if m < 0 { out[0] = 45 as u8; o = 1; m = 0 - m }
  if m == 0 { out[o] = 48 as u8; return o + 1 }
  var nd: i64 = 1
  var mm: i64 = m
  while mm >= 10 { nd = nd + 1; mm = mm / 10 }
  var i: i64 = nd - 1
  while m > 0 { out[o + i] = (48 + (m % 10)) as u8; m = m / 10; i = i - 1 }
  return o + nd
43}
44func cr_pn(v: i64) -> i64 { let b: *u8 = sys_mmap(28); let n: i64 = cr_decw(v, b); sys_write(1, b, n); sys_munmap(b, 28); return 0 }
45func cr_contains(hay: *u8, hlen: i64, needle: *u8) -> i64 {
  let nlen: i64 = cr_slen(needle)
  if hlen < nlen { return 0 }
  var s: i64 = 0
  let last: i64 = hlen - nlen
  while s <= last {
      var m: i64 = 0
      var eq: i64 = 1
      while m < nlen { if hay[s + m] != needle[m] { eq = 0; m = nlen } m = m + 1 }
      if eq == 1 { return 1 }
      s = s + 1
  }
  return 0
58}
59func cr_line_end(buf: *u8, pos: i64, end: i64) -> i64 {
  var p: i64 = pos
  while p < end { if (buf[p] as i64) == 10 { return p } p = p + 1 }
  return end
63}
64func cr_read(path: *u8, buf: *u8, cap: i64) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 - 1 }
  let n: i64 = sys_read(fd, buf, cap - 1)
  sys_close(fd)
  return n
70}
71
72func main(argc: i64, argv: *i64) -> i64 {
  if argc < 3 { cr_p("usage: nx_cron_reconcile <crontab-path> <reg-path>\n" as *u8); return 2 }
  let ctpath: *u8 = argv[1] as *u8
  let regpath: *u8 = argv[2] as *u8
  let ct:  *u8 = sys_mmap(CR_CTCAP)
  let reg: *u8 = sys_mmap(CR_REGCAP)
  let out: *u8 = sys_mmap(CR_CTCAP + CR_REGCAP)
  let np:  *u8 = sys_mmap(512)
80
  // R4: crontab must exist and be non-empty
  let cn: i64 = cr_read(ctpath, ct, CR_CTCAP)
  if cn <= 0 { cr_p("REFUSED: crontab unreadable/empty (a boot file is never empty) -- no write\n" as *u8); return 4 }
  // R2: registry must exist with >=1 declared row; R3: every row must carry the nishi mark
  let rn: i64 = cr_read(regpath, reg, CR_REGCAP)
  if rn <= 0 { cr_p("REFUSED: cron.reg missing/empty -- an absent SSOT never wipes rows\n" as *u8); return 3 }
  var decl: i64 = 0
  var pos: i64 = 0
  while pos < rn {
      let le: i64 = cr_line_end(reg, pos, rn)
      if le > pos { if (reg[pos] as i64) != 35 { if (reg[pos] as i64) != 13 {
          if cr_contains((((reg as i64) + pos)) as *u8, le - pos, CR_MARK) == 0 {
              cr_p("REFUSED: declared row lacks /nishihost/ (registry taint -- this organ cannot manage non-nishi rows)\n" as *u8)
              return 5
          }
          decl = decl + 1
      } } }
      pos = le + 1
  }
  if decl == 0 { cr_p("REFUSED: cron.reg has no declared rows -- no write\n" as *u8); return 3 }
101
  // build: non-nishi crontab lines byte-exact, then the declared block
  var w: i64 = 0
  var removed: i64 = 0
  pos = 0
  while pos < cn {
      let le2: i64 = cr_line_end(ct, pos, cn)
      if cr_contains((((ct as i64) + pos)) as *u8, le2 - pos, CR_MARK) == 1 { removed = removed + 1 }
      else {
          var k: i64 = pos
          while k < le2 { out[w] = ct[k]; w = w + 1; k = k + 1 }
          out[w] = 10 as u8
          w = w + 1
      }
      pos = le2 + 1
  }
  pos = 0
  while pos < rn {
      let le3: i64 = cr_line_end(reg, pos, rn)
      if le3 > pos { if (reg[pos] as i64) != 35 { if (reg[pos] as i64) != 13 {
          var k2: i64 = pos
          while k2 < le3 { out[w] = reg[k2]; w = w + 1; k2 = k2 + 1 }
          out[w] = 10 as u8
          w = w + 1
      } } }
      pos = le3 + 1
  }
128
  // R5: idempotence -- byte-identical means zero writes
  var same: i64 = 0
  if w == cn {
      same = 1
      var ci: i64 = 0
      while ci < cn { if out[ci] != ct[ci] { same = 0; ci = cn } ci = ci + 1 }
  }
  if same == 1 {
      cr_p("NO-CHANGE (crontab already matches cron.reg; declared=" as *u8)
      cr_pn(decl)
      cr_p(")\n" as *u8)
      return 0
  }
142
  // R6: atomic write -- <path>.nxnew then rename over
  var npw: i64 = 0
  var pi: i64 = 0
  while ctpath[pi] != (0 as u8) { np[npw] = ctpath[pi]; npw = npw + 1; pi = pi + 1 }
  let sfx: *u8 = ".nxnew" as *u8
  var si: i64 = 0
  while sfx[si] != (0 as u8) { np[npw] = sfx[si]; npw = npw + 1; si = si + 1 }
  np[npw] = 0 as u8
  let wfd: i64 = sys_openat_wr(np, 420)
  if wfd < 0 { cr_p("WRITE-FAIL: cannot create .nxnew (permission?) -- crontab untouched\n" as *u8); return 6 }
  var off: i64 = 0
  while off < w {
      let wr: i64 = sys_write(wfd, (((out as i64) + off)) as *u8, w - off)
      if wr <= 0 { sys_close(wfd); cr_p("WRITE-FAIL: short write on .nxnew -- crontab untouched\n" as *u8); return 6 }
      off = off + wr
  }
  sys_close(wfd)
  if sys_renameat(np, ctpath) != 0 { cr_p("WRITE-FAIL: rename over crontab failed -- crontab untouched\n" as *u8); return 6 }
  cr_p("CHANGED: nishi-rows removed=" as *u8)
  cr_pn(removed)
  cr_p(" declared=" as *u8)
  cr_pn(decl)
  cr_p(" bytes " as *u8)
  cr_pn(cn)
  cr_p("->" as *u8)
  cr_pn(w)
  cr_p("\n" as *u8)
170
  // SIGHUP crond so the in-memory schedule reloads (safe standard reload; no-op if none found)
  let dfd: i64 = sys_openat_rd("/proc\x00" as *u8)
  if dfd >= 0 {
      let dbuf: *u8 = sys_mmap(CR_MAGIC_65536)
      let cpath: *u8 = sys_mmap(64)
      let cbuf: *u8 = sys_mmap(32)
      var hup: i64 = 0
      var reading: i64 = 1
      while reading == 1 {
          let dn: i64 = sys_getdents64(dfd, dbuf, CR_MAGIC_65536)
          if dn <= 0 { reading = 0 }
          else {
              var doff: i64 = 0
              while doff < dn {
                  let recp: *u8 = (((dbuf as i64) + doff)) as *u8
                  let reclen: i64 = dirent_reclen(recp)
                  let nm: *u8 = dirent_name(recp)
                  if nm[0] >= (48 as u8) { if nm[0] <= (57 as u8) {
                      var qi: i64 = 0
                      let pre: *u8 = "/proc/" as *u8
                      var ppi: i64 = 0
                      while pre[ppi] != (0 as u8) { cpath[ppi] = pre[ppi]; ppi = ppi + 1 }
                      while nm[qi] != (0 as u8) { cpath[ppi] = nm[qi]; ppi = ppi + 1; qi = qi + 1 }
                      let suf: *u8 = "/comm" as *u8
                      var ssi: i64 = 0
                      while suf[ssi] != (0 as u8) { cpath[ppi] = suf[ssi]; ppi = ppi + 1; ssi = ssi + 1 }
                      cpath[ppi] = 0 as u8
                      let cfd: i64 = sys_openat_rd(cpath)
                      if cfd >= 0 {
                          let cl: i64 = sys_read(cfd, cbuf, 31)
                          sys_close(cfd)
                          // comm == "crond\n"
                          if cl >= 5 { if cbuf[0]==(99 as u8) { if cbuf[1]==(114 as u8) { if cbuf[2]==(111 as u8) { if cbuf[3]==(110 as u8) { if cbuf[4]==(100 as u8) {
                              var tail_ok: i64 = 0
                              if cl == 5 { tail_ok = 1 }
                              if cl == 6 { if (cbuf[5] as i64) == 10 { tail_ok = 1 } }
                              if tail_ok == 1 {
                                  var pid: i64 = 0
                                  var di: i64 = 0
                                  while nm[di] != (0 as u8) { pid = pid * 10 + ((nm[di] as i64) - 48); di = di + 1 }
                                  nx_kill(pid, 1)
                                  hup = hup + 1
                              }
                          } } } } } }
                      }
                  } }
                  doff = doff + reclen
              }
          }
      }
      sys_close(dfd)
      cr_p("crond HUP'd: " as *u8)
      cr_pn(hup)
      cr_p("\n" as *u8)
  }
  return 0
227}
nx_cron_reconcile.nx source

`nx_cron_reconcile.nx` source
