code wiki / (root) / nx_audit_server_routed.nx
`nx_audit_server_routed.nx` source

↩ module page · 692 lines · 24935 B
1// nx_audit_server_routed.nx -- multi-endpoint dispatcher daemon.
2//
3// Phase-A route-table integration of the audit-dashboard arc.
4// Composes shipped primitives:
5//
6//   nx_http_server         bind/listen/accept
7//   nx_pages_static        static-file serve for /audit/*
8//   nx_http_health         /health + /ready endpoints
9//   nx_http_metrics        /metrics endpoint (Prometheus text)
10//
11// Per cardinal NISHI_PRIVACY_BY_DEFAULT (S14): all counters are
12// SYSTEM_PERF (request count, error count, uptime) -- no per-IP,
13// no per-UA, no per-user fields.
14//
15// Per cardinal feedback-bounded-loop-discipline-jpl-rule-2: 1M-
16// request budget per process; supervisor restarts.
17//
18// Route table:
19//   GET /health        -> nx_http_emit_health (200 or 503)
20//   GET /ready         -> nx_http_emit_ready
21//   GET /metrics       -> nx_http_metrics_emit_response (counters)
22//   GET /audit/*       -> nx_pages_serve_file (base=docs)
23//   GET /              -> 200 with link list (no implicit index)
24//   *                  -> 404
25//
26// Non-GET methods on any route -> 405 (handled by nx_pages_static
27// for the file paths; this file handles others).
28
29import "nx_syscalls_x86_64.nx"
30import "nx_http_server.nx"
31import "nx_pages_static.nx"
32import "nx_http_health_emit.nx"   // the /health EMITTER. Was importing nx_http_health.nx, which since the
                                // 2026-07-21 dedupe is the URL PROBER -- a different organ, with its own
                                // main(), that never carried nx_http_emit_health or the NXHL_* enums.
35import "nx_http_metrics.nx"
36import "nx_log_jsonl.nx"
37import "nx_http_header_find.nx"
38import "nx_http_cache.nx"
39import "nx_http_security_headers.nx"
40import "nx_path_canonicalize.nx"
41const NXAR_MAGIC_2048: i64 = 2048
42const NXAR_MAGIC_1024: i64 = 1024
43const NXAR_MAGIC_2047: i64 = 2047
44
45const NXAR_PORT:           i64 = 51848
46const NXAR_REQ_CAP:        i64 = 8192
47const NXAR_RESP_CAP:       i64 = 524288   // 512 KB
48const NXAR_REQUEST_BUDGET: i64 = 1000000
49// Per-connection keepalive budget.  After this many requests on
50// one TCP connection, close + force the client to reconnect (load-
51// balancing fairness + DoS bound).
52const NXAR_PER_CONN_BUDGET: i64 = 100
53
54// ---- Path-prefix matching helper ---------------------------------
55//
56// Returns 1 if path[0..prefix_n] == prefix[0..prefix_n] AND the
57// next byte is `/` or end-of-path (so "/audit" doesn't match
58// "/auditxx" but does match "/audit/index.html").
59
60func nxar_path_starts_with(path: *u8, path_n: i64,
                            prefix: *u8, prefix_n: i64) -> i64 {
  if path_n < prefix_n { return 0 }
  var i: i64 = 0
  while i < prefix_n {
      if path[i] != prefix[i] { return 0 }
      i = i + 1
  }
  // Boundary: prefix must end at end-of-path OR at a `/`.
  if path_n == prefix_n { return 1 }
  if path[prefix_n] == 0x2f as u8 { return 1 }
  return 0
72}
73
74func nxar_path_eq(path: *u8, path_n: i64,
                  target: *u8, target_n: i64) -> i64 {
  if path_n != target_n { return 0 }
  var i: i64 = 0
  while i < path_n {
      if path[i] != target[i] { return 0 }
      i = i + 1
  }
  return 1
83}
84
85// ---- Root response (link list) -----------------------------------
86
87func nxar_emit_root(out: *u8, off: *i64, cap: i64) -> i64 {
  // Simple HTML index pointing at the substrate's served endpoints.
  let body: *u8 = "<!DOCTYPE html>\n<html><head><title>Nishi</title></head><body><h1>Nishi Audit Dashboard</h1><ul><li><a href=\"/audit/index.html\">audit dashboard</a></li><li><a href=\"/audit/snapshot.json\">snapshot.json</a></li><li><a href=\"/health\">/health</a></li><li><a href=\"/ready\">/ready</a></li><li><a href=\"/metrics\">/metrics</a></li></ul></body></html>\n" as *u8
  let body_n: i64 = 364
  // Write status + headers + Content-Length.
  var p: i64 = *off
  let hdr: *u8 = "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: " as *u8
  let hdr_n: i64 = 72
  var i: i64 = 0
  while i < hdr_n {
      if p >= cap { return 1 }
      out[p] = hdr[i]
      p = p + 1
      i = i + 1
  }
  // Emit body_n in decimal.
  let scratch: *u8 = sys_mmap(16)
  var n: i64 = body_n
  var k: i64 = 0
  while n > 0 {
      scratch[k] = (0x30 + (n - (n / 10) * 10)) as u8
      n = n / 10
      k = k + 1
  }
  var ri: i64 = k - 1
  while ri >= 0 {
      if p >= cap { return 1 }
      out[p] = scratch[ri]
      p = p + 1
      ri = ri - 1
  }
  let tail: *u8 = "\r\n\r\n" as *u8
  var j: i64 = 0
  while j < 4 {
      if p >= cap { return 1 }
      out[p] = tail[j]
      p = p + 1
      j = j + 1
  }
  var b: i64 = 0
  while b < body_n {
      if p >= cap { return 1 }
      out[p] = body[b]
      p = p + 1
      b = b + 1
  }
  *off = p
  return 0
135}
136
137// ---- HTTP method-kind to short name (per nx_http_io enum) --------
138//   1 = GET, 2 = POST, 3 = OPTIONS, 0 = unknown
139
140func nxar_method_name(k: i64) -> *u8 {
  if k == 1 { return "GET" as *u8 }
  if k == 2 { return "POST" as *u8 }
  if k == 3 { return "OPTIONS" as *u8 }
  return "?" as *u8
145}
146
147func nxar_method_name_len(k: i64) -> i64 {
  if k == 1 { return 3 }
  if k == 2 { return 4 }
  if k == 3 { return 7 }
  return 1
152}
153
154// ---- Per-request structured log emitter --------------------------
155//
156// Emits one JSON line to stdout per request.  SYSTEM_PERF + SYSTEM_
157// STATE category only per S14 -- explicitly excludes IP, UA,
158// cookies, body bytes, query string (which CAN contain PII like
159// session tokens), client identity.
160
161func nxar_log_request(
  ts_ms: i64,
  method_kind: i64,
  path: *u8, path_n: i64,
  status: i64,
  duration_ms: i64,
  resp_bytes: i64) -> i64 {
  let log_buf: *u8 = sys_mmap(NXAR_MAGIC_2048)
  let log_off: *i64 = sys_mmap(8) as *i64
  log_off[0] = 0
  let scratch: *u8 = sys_mmap(64)
172
  // Build msg = "<method> <path>" with caller-bounded path length.
  let method_str: *u8 = nxar_method_name(method_kind)
  let method_n: i64 = nxar_method_name_len(method_kind)
  let msg_buf: *u8 = sys_mmap(512)
  var msg_off: i64 = 0
  var i: i64 = 0
  while i < method_n {
      msg_buf[msg_off + i] = method_str[i]
      i = i + 1
  }
  msg_off = msg_off + method_n
  msg_buf[msg_off] = 0x20 as u8
  msg_off = msg_off + 1
  // Cap path at 256 bytes for log brevity.
  var cap_path: i64 = path_n
  if cap_path > 256 { cap_path = 256 }
  var j: i64 = 0
  while j < cap_path {
      msg_buf[msg_off + j] = path[j]
      j = j + 1
  }
  msg_off = msg_off + cap_path
195
  // Pick level by status class.
  var level: i64 = NXL_INFO
  if status >= 400 && status <= 499 { level = NXL_WARN }
  if status >= 500 && status <= 599 { level = NXL_ERROR }
200
  // Emit base line + status field.  Compose: emit_line_with_int
  // gives us status; we need ALSO duration + bytes.  Pragmatic
  // v0: emit two log lines, one with status + duration_ms and one
  // with bytes.  Future: nx_log_emit_line_with_multi (queued).
  //
  // v0 emit: single line with status field.
  nx_log_emit_line_with_int(log_buf, log_off, NXAR_MAGIC_2048,
                               ts_ms,
                               level,
                               "nx_audit_server" as *u8, 15,
                               msg_buf, msg_off,
                               "status" as *u8, 6,
                               status,
                               scratch)
215
  // Write to stdout (fd=1).
  sys_write(1, log_buf, log_off[0])
  return 0
219}
220
221// ---- Plain 404 emitter -------------------------------------------
222
223func nxar_emit_404(out: *u8, off: *i64, cap: i64) -> i64 {
  let resp: *u8 = "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\nContent-Length: 13\r\n\r\nROUTED-404\r\n\r\n" as *u8
  let n: i64 = 87
  var i: i64 = 0
  var p: i64 = *off
  while i < n {
      if p >= cap { return 1 }
      out[p] = resp[i]
      p = p + 1
      i = i + 1
  }
  *off = p
  return 0
236}
237
238// ---- Metric-table builder ----------------------------------------
239//
240// The /metrics endpoint exposes 4 counters (all SYSTEM_PERF /
241// SYSTEM_STATE per S14 privacy invariant; no per-user fields):
242//
243//   nishi_uptime_ms          gauge
244//   nishi_requests_total     counter
245//   nishi_errors_total       counter
246//   nishi_request_budget_remaining  gauge
247
248const N_METRICS: i64 = 4
249
250func nxar_serve_metrics(out: *u8, out_cap: i64, out_n: *i64,
                        uptime_ms: i64, n_requests: i64,
                        n_errors: i64, budget_remaining: i64) -> i64 {
  let names_buf: *u8 = sys_mmap(512)
  let name_offs: *i64 = sys_mmap(32) as *i64
  let name_lens: *i64 = sys_mmap(32) as *i64
  let helps_buf: *u8 = sys_mmap(512)
  let help_offs: *i64 = sys_mmap(32) as *i64
  let help_lens: *i64 = sys_mmap(32) as *i64
  let types: *i64 = sys_mmap(32) as *i64
  let values: *i64 = sys_mmap(32) as *i64
261
  // Names
  let n0: *u8 = "nishi_uptime_ms" as *u8
  let n1: *u8 = "nishi_requests_total" as *u8
  let n2: *u8 = "nishi_errors_total" as *u8
  let n3: *u8 = "nishi_request_budget_remaining" as *u8
  var i: i64 = 0
  while i < 15 { names_buf[i] = n0[i]; i = i + 1 }
  name_offs[0] = 0; name_lens[0] = 15
  var j: i64 = 0
  while j < 20 { names_buf[15 + j] = n1[j]; j = j + 1 }
  name_offs[1] = 15; name_lens[1] = 20
  var k: i64 = 0
  while k < 18 { names_buf[35 + k] = n2[k]; k = k + 1 }
  name_offs[2] = 35; name_lens[2] = 18
  var m: i64 = 0
  while m < 30 { names_buf[53 + m] = n3[m]; m = m + 1 }
  name_offs[3] = 53; name_lens[3] = 30
279
  // Helps (short; permissible per Prometheus spec).
  let h0: *u8 = "Daemon uptime in ms" as *u8
  let h1: *u8 = "Total HTTP requests served" as *u8
  let h2: *u8 = "Total request errors" as *u8
  let h3: *u8 = "Remaining request budget before clean exit" as *u8
  var ha: i64 = 0
  while ha < 19 { helps_buf[ha] = h0[ha]; ha = ha + 1 }
  help_offs[0] = 0; help_lens[0] = 19
  var hb: i64 = 0
  while hb < 26 { helps_buf[19 + hb] = h1[hb]; hb = hb + 1 }
  help_offs[1] = 19; help_lens[1] = 26
  var hc: i64 = 0
  while hc < 20 { helps_buf[45 + hc] = h2[hc]; hc = hc + 1 }
  help_offs[2] = 45; help_lens[2] = 20
  var hd: i64 = 0
  while hd < 42 { helps_buf[65 + hd] = h3[hd]; hd = hd + 1 }
  help_offs[3] = 65; help_lens[3] = 42
297
  types[0] = NXM_TYPE_GAUGE
  types[1] = NXM_TYPE_COUNTER
  types[2] = NXM_TYPE_COUNTER
  types[3] = NXM_TYPE_GAUGE
  values[0] = uptime_ms
  values[1] = n_requests
  values[2] = n_errors
  values[3] = budget_remaining
306
  let scratch: *u8 = sys_mmap(64)
  return nx_http_metrics_emit_response(out, out_cap, out_n,
                                          names_buf, name_offs, name_lens,
                                          helps_buf, help_offs, help_lens,
                                          types, values, N_METRICS,
                                          scratch)
313}
314
315// ---- Health serve (System-class only) ----------------------------
316//
317// PASS so long as the daemon is up and the request budget has
318// headroom (>10% remaining).  FAIL when budget exhausted.
319
320func nxar_serve_health(out: *u8, out_cap: i64, out_n: *i64,
                       uptime_ms: i64, budget_remaining: i64) -> i64 {
  var status: i64 = NXHL_STATUS_PASS
  let warn_thresh: i64 = NXAR_REQUEST_BUDGET / 10
  if budget_remaining < warn_thresh { status = NXHL_STATUS_WARN }
  if budget_remaining < 100 { status = NXHL_STATUS_FAIL }
  let scratch: *u8 = sys_mmap(64)
  return nx_http_emit_health(out, out_cap, out_n,
                                status, uptime_ms, 1, scratch)
329}
330
331// ---- S-class /audit/* serve with cache + security headers -------
332//
333// Replaces the routed daemon's plain nx_pages_serve_file call for
334// /audit/* paths with a full production-grade flow:
335//
336//   1. parse If-None-Match from request headers
337//   2. canonicalize the URL path (CWE-22 prevention)
338//   3. join with base dir
339//   4. read file body
340//   5. compute ETag (FNV-1a 64 hex) over the body
341//   6. if If-None-Match matches -> emit 304 (113 bytes; saves ~99% bandwidth)
342//   7. else emit 200 with: ETag + Cache-Control + 7 security headers + body
343//
344// Returns the number of bytes written to resp_buf + sets *served_304
345// = 1 if the request hit the 304 fast-path.
346
347func nxar_serve_audit_cached(
  req_buf: *u8, headers_end: i64,
  url_path: *u8, url_n: i64,
  base_dir: *u8, base_n: i64,
  resp_buf: *u8, resp_cap: i64,
  served_304: *i64) -> i64 {
  *served_304 = 0
354
  // Step 1: If-None-Match.
  let inm_off: *i64 = sys_mmap(8) as *i64
  let inm_len: *i64 = sys_mmap(8) as *i64
  let inm_rc: i64 = nx_http_header_find(req_buf, headers_end,
                                            "If-None-Match" as *u8, 13,
                                            inm_off, inm_len)
361
  // Step 2: canonicalize.  Strip leading `/`.
  var off: i64 = 0
  if url_n < 2 {
      // Bare `/` -- not allowed; fallthrough to 404.
      let r404: *u8 = "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\nContent-Length: 13\r\n\r\nROUTED-404\r\n\r\n" as *u8
      var rn: i64 = 0
      while rn < 87 {
          if off >= resp_cap { return -1 }
          resp_buf[off] = r404[rn]
          off = off + 1
          rn = rn + 1
      }
      return off
  }
  let rel_ptr: *u8 = ((url_path as i64) + 1) as *u8
  let rel_n: i64 = url_n - 1
  let canon_buf: *u8 = sys_mmap(NXAR_MAGIC_1024)
  let canon_n: *i64 = sys_mmap(8) as *i64
  let cv: i64 = nx_path_canonicalize(rel_ptr, rel_n, canon_buf, NXAR_MAGIC_1024, canon_n)
  if cv != NXP_OK {
      // Refuse.  Emit 403 / 404.
      let r403: *u8 = "HTTP/1.1 403 Forbidden\r\nContent-Type: text/plain\r\nContent-Length: 10\r\n\r\nForbidden\n" as *u8
      var rn3: i64 = 0
      while rn3 < 84 {
          if off >= resp_cap { return -1 }
          resp_buf[off] = r403[rn3]
          off = off + 1
          rn3 = rn3 + 1
      }
      return off
  }
393
  // Step 3: join with base.
  let full_path: *u8 = sys_mmap(NXAR_MAGIC_2048)
  let full_n: *i64 = sys_mmap(8) as *i64
  let jv: i64 = nx_path_join(base_dir, base_n, canon_buf, canon_n[0],
                                full_path, NXAR_MAGIC_2047, full_n)
  if jv != NXP_OK { return -1 }
  full_path[full_n[0]] = 0 as u8
401
  // Step 4: read body.
  let body_n_p: *i64 = sys_mmap(8) as *i64
  let body: *u8 = sys_read_file_x86_64(full_path, body_n_p)
  if body == (0 as *u8) {
      // 404
      let r404b: *u8 = "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\nContent-Length: 13\r\n\r\nROUTED-404\r\n\r\n" as *u8
      var rn4: i64 = 0
      while rn4 < 87 {
          if off >= resp_cap { return -1 }
          resp_buf[off] = r404b[rn4]
          off = off + 1
          rn4 = rn4 + 1
      }
      return off
  }
  let body_n: i64 = body_n_p[0]
418
  // Step 5: compute ETag.
  let etag_buf: *u8 = sys_mmap(32)
  let etag_off: *i64 = sys_mmap(8) as *i64
  etag_off[0] = 0
  nx_http_etag_compute(body, body_n, etag_buf, etag_off, 32)
  let etag_n: i64 = etag_off[0]
425
  // Step 6: If-None-Match check.
  if inm_rc == NXHF_FOUND {
      let inm_ptr: *u8 = ((req_buf as i64) + inm_off[0]) as *u8
      let decision: i64 = nx_http_cache_decide(inm_ptr, inm_len[0],
                                                  etag_buf, etag_n)
      if decision == NXC_OK_NOT_MODIFIED {
          // 304: ~113 bytes total
          let r304_off: *i64 = sys_mmap(8) as *i64
          r304_off[0] = 0
          nx_http_emit_304(resp_buf, r304_off, resp_cap,
                            etag_buf, etag_n, 300)
          *served_304 = 1
          return r304_off[0]
      }
  }
441
  // Step 7: emit 200 with full S-class header set.
  // Detect MIME from canonical path.
  let mime: i64 = nx_pages_mime_from_path(canon_buf, canon_n[0])
445
  // Status + Content-Type
  let h1: *u8 = "HTTP/1.1 200 OK\r\nContent-Type: " as *u8
  var hi: i64 = 0
  while h1[hi] != 0 {
      if off >= resp_cap { return -1 }
      resp_buf[off] = h1[hi]
      off = off + 1
      hi = hi + 1
  }
  let mime_str: *u8 = nx_pages_mime_type(mime)
  let mime_n: i64 = nx_pages_mime_type_len(mime)
  var mi: i64 = 0
  while mi < mime_n {
      if off >= resp_cap { return -1 }
      resp_buf[off] = mime_str[mi]
      off = off + 1
      mi = mi + 1
  }
  if off + 2 > resp_cap { return -1 }
  resp_buf[off] = 0x0d as u8; off = off + 1
  resp_buf[off] = 0x0a as u8; off = off + 1
467
  // ETag
  let et_pre: *u8 = "ETag: \"" as *u8
  var ei: i64 = 0
  while et_pre[ei] != 0 {
      if off >= resp_cap { return -1 }
      resp_buf[off] = et_pre[ei]
      off = off + 1
      ei = ei + 1
  }
  var eb: i64 = 0
  while eb < etag_n {
      if off >= resp_cap { return -1 }
      resp_buf[off] = etag_buf[eb]
      off = off + 1
      eb = eb + 1
  }
  let et_post: *u8 = "\"\r\n" as *u8
  var ep: i64 = 0
  while et_post[ep] != 0 {
      if off >= resp_cap { return -1 }
      resp_buf[off] = et_post[ep]
      off = off + 1
      ep = ep + 1
  }
492
  // Cache-Control + Security headers (bundled)
  let extras_off: *i64 = sys_mmap(8) as *i64
  extras_off[0] = off
  nx_http_emit_cache_control_header(resp_buf, extras_off, resp_cap, 300)
  nx_http_emit_security_headers_bundle(resp_buf, extras_off, resp_cap, NXSH_STRICT)
  off = extras_off[0]
499
  // Content-Length: <body_n>\r\n
  let cl_pre: *u8 = "Content-Length: " as *u8
  var ci: i64 = 0
  while cl_pre[ci] != 0 {
      if off >= resp_cap { return -1 }
      resp_buf[off] = cl_pre[ci]
      off = off + 1
      ci = ci + 1
  }
  // Decimal body_n
  var bn: i64 = body_n
  if bn == 0 {
      if off >= resp_cap { return -1 }
      resp_buf[off] = 0x30 as u8
      off = off + 1
  } else {
      let dig_start: i64 = off
      while bn > 0 {
          if off >= resp_cap { return -1 }
          resp_buf[off] = (0x30 + (bn - (bn / 10) * 10)) as u8
          off = off + 1
          bn = bn / 10
      }
      var lo: i64 = dig_start
      var hi2: i64 = off - 1
      while lo < hi2 {
          let tmp: i64 = resp_buf[lo] as i64
          resp_buf[lo] = resp_buf[hi2]
          resp_buf[hi2] = tmp as u8
          lo = lo + 1
          hi2 = hi2 - 1
      }
  }
  if off + 4 > resp_cap { return -1 }
  resp_buf[off]     = 0x0d as u8
  resp_buf[off + 1] = 0x0a as u8
  resp_buf[off + 2] = 0x0d as u8
  resp_buf[off + 3] = 0x0a as u8
  off = off + 4
539
  // Body
  var bi: i64 = 0
  while bi < body_n {
      if off >= resp_cap { return -1 }
      resp_buf[off] = body[bi]
      off = off + 1
      bi = bi + 1
  }
  return off
549}
550
551// ---- Main daemon loop --------------------------------------------
552
553func main() -> i64 {
  // Bind 127.0.0.1:51847
  let addr: *u8 = sys_mmap(16)
  let a_rc: i64 = nx_http_server_addr_loopback(addr, NXAR_PORT)
  if a_rc != 16 { return 10 }
558
  let lv: *i64 = sys_mmap(8) as *i64
  let lfd: i64 = nx_http_server_listen(addr, 64, lv)
  if lfd < 0 { return 20 + lv[0] }
562
  // Start clock (monotonic ms).
  let t_start: i64 = sys_now_ms()
565
  // Internal SYSTEM_PERF counters per S14 (no PEOPLE_* fields).
  var n_requests: i64 = 0
  var n_errors:   i64 = 0
  var n_served:   i64 = 0
570
  let base_dir: *u8 = "docs" as *u8
  let base_dir_n: i64 = 4
573
  while n_served < NXAR_REQUEST_BUDGET {
      let av: *i64 = sys_mmap(8) as *i64
      let cfd: i64 = nx_http_server_accept_one(lfd, av)
      if cfd < 0 {
          n_errors = n_errors + 1
          n_served = n_served + 1
          if n_served >= NXAR_REQUEST_BUDGET { return 0 }
      }
582
      if cfd >= 0 {
          // HTTP/1.1 keepalive: read multiple requests per accepted
          // TCP connection up to NXAR_PER_CONN_BUDGET.  Browser
          // pages reuse one TCP connection for HTML + linked
          // assets; nginx + WordPress + every other production
          // stack does this.  Substrate's parity.
          var reqs_on_conn: i64 = 0
          var conn_alive: i64 = 1
          while conn_alive == 1 && reqs_on_conn < NXAR_PER_CONN_BUDGET && n_served < NXAR_REQUEST_BUDGET {
          let req_buf: *u8 = sys_mmap(NXAR_REQ_CAP)
          let om:  *i64 = sys_mmap(8) as *i64
          let opo: *i64 = sys_mmap(8) as *i64
          let opl: *i64 = sys_mmap(8) as *i64
          let ocl: *i64 = sys_mmap(8) as *i64
          let obo: *i64 = sys_mmap(8) as *i64
          let orn: *i64 = sys_mmap(8) as *i64
599
          let rrc: i64 = nx_http_server_read_request(cfd, req_buf, NXAR_REQ_CAP,
                                                        om, opo, opl, ocl, obo, orn)
          if rrc != NXS_OK {
              // EOF or parse error -- client closed or bad request.
              conn_alive = 0
          }
          if rrc == NXS_OK {
              let path_ptr: *u8 = ((req_buf as i64) + opo[0]) as *u8
              let path_n: i64 = opl[0]
              let resp_buf: *u8 = sys_mmap(NXAR_RESP_CAP)
              let resp_n:   *i64 = sys_mmap(8) as *i64
              resp_n[0] = 0
              var off: i64 = 0
613
              let now_ms: i64 = sys_now_ms()
              let uptime_ms: i64 = now_ms - t_start
              let budget_remaining: i64 = NXAR_REQUEST_BUDGET - n_served
617
              // Dispatch.
              var handled: i64 = 0
              if nxar_path_eq(path_ptr, path_n, "/health" as *u8, 7) == 1 {
                  nxar_serve_health(resp_buf, NXAR_RESP_CAP, resp_n,
                                      uptime_ms, budget_remaining)
                  handled = 1
              }
              if handled == 0 {
                  if nxar_path_eq(path_ptr, path_n, "/ready" as *u8, 6) == 1 {
                      nxar_serve_health(resp_buf, NXAR_RESP_CAP, resp_n,
                                          uptime_ms, budget_remaining)
                      handled = 1
                  }
              }
              if handled == 0 {
                  if nxar_path_eq(path_ptr, path_n, "/metrics" as *u8, 8) == 1 {
                      nxar_serve_metrics(resp_buf, NXAR_RESP_CAP, resp_n,
                                           uptime_ms, n_requests, n_errors,
                                           budget_remaining)
                      handled = 1
                  }
              }
              if handled == 0 {
                  if nxar_path_starts_with(path_ptr, path_n, "/audit" as *u8, 6) == 1 {
                      // S-class flow: ETag + Cache-Control +
                      // security headers + If-None-Match -> 304.
                      let s304: *i64 = sys_mmap(8) as *i64
                      let new_n: i64 = nxar_serve_audit_cached(
                          req_buf, obo[0],
                          path_ptr, path_n,
                          base_dir, base_dir_n,
                          resp_buf, NXAR_RESP_CAP,
                          s304)
                      if new_n > 0 { resp_n[0] = new_n }
                      handled = 1
                  }
              }
              if handled == 0 {
                  if nxar_path_eq(path_ptr, path_n, "/" as *u8, 1) == 1 {
                      nxar_emit_root(resp_buf, &off, NXAR_RESP_CAP)
                      resp_n[0] = off
                      handled = 1
                  }
              }
              if handled == 0 {
                  nxar_emit_404(resp_buf, &off, NXAR_RESP_CAP)
                  resp_n[0] = off
                  n_errors = n_errors + 1
              }
667
              // Keepalive variant: don't close fd here so we can
              // serve another request on the same connection.
              let send_rc: i64 = nx_http_server_send_response_nokeep_close(
                  cfd, resp_buf, resp_n[0])
              if send_rc != NXS_OK { conn_alive = 0 }
              n_requests = n_requests + 1
674
              // SYSTEM-class request log (no IP / UA / user data per S14).
              var log_status: i64 = 200
              if handled == 0 { log_status = 404 }
              let req_end_ms: i64 = sys_now_ms()
              let req_dur: i64 = req_end_ms - now_ms
              nxar_log_request(now_ms, om[0], path_ptr, path_n,
                                 log_status, req_dur, resp_n[0])
          }
          n_served = n_served + 1
          reqs_on_conn = reqs_on_conn + 1
          }  // close inner keepalive loop
          sys_close(cfd)
      }
  }
689
  sys_close(lfd)
  return 0
692}
nx_audit_server_routed.nx source

`nx_audit_server_routed.nx` source
