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

↩ module page · 229 lines · 11508 B
1// nx_media_cover_lib.nx -- SOVEREIGN book-cover resolution for the media server (/api/cover).
2// A book's embedded cover is extracted to knowledge/staging/media/reader/<slug>/<coverfile> as a side effect of
3// decoding (nx_epub_book / nx_mobi_book / nx_kf8_book all write the image + record "cover":"<file>" in book.json).
4// This lib maps a NAS book path -> that on-disk cover image, extracting on cache-miss, so the library grid can show
5// real covers WITHOUT generating or downloading anything (operator: no internet, extract embedded only). Shared by
6// nx_media_server (serve) and nx_media_cover_gate (test) so the slug + resolution logic has ONE definition.
7// license_tier: ORIGINAL
8import "nx_syscalls.nx"
9import "nx_itoa_lib.nx"   // THE shared MSB-first emitter -- mc_dec composes it
10const MC_MAGIC_1469598103: i64 = 1469598103
11const MC_MAGIC_72057594037927931: i64 = 72057594037927931
12const MC_MAGIC_262144: i64 = 262144
13
14const MC_READER_ROOT: *u8 = "knowledge/staging/media/reader/"
15
16func mc_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
17func mc_app(dst: *u8, off: i64, src: *u8, n: i64) -> i64 { var i: i64 = 0; while i < n { dst[off+i] = src[i]; i = i + 1 } return off + n }
18func mc_apps(dst: *u8, off: i64, s: *u8) -> i64 { return mc_app(dst, off, s, mc_slen(s)) }
19// ★COMPOSES nxi_buf (2026-08-15, found by nx_itoaclone). Same three defects as every clone of this
20// shape: a negative emitted ZERO BYTES, INT64_MIN would emit a lone '-', and sys_mmap(28) PER CALL was
21// never freed. Identical contract (digits only, no NUL, returns the offset after them).
22func mc_dec(dst: *u8, off: i64, v: i64) -> i64 { return nxi_buf(dst, off, v) }
23func mc_hexc(d: i64) -> i64 { if d < 10 { return 48 + d } return 87 + d }
24
25// 1 if hay[0..hl] contains the needle (path-traversal guard).
26func mc_contains(hay: *u8, hl: i64, needle: *u8) -> i64 {
  let nl: i64 = mc_slen(needle)
  if nl == 0 { return 0 }
  var i: i64 = 0
  while i + nl <= hl {
      var k: i64 = 0; var hit: i64 = 1
      while k < nl { if hay[i+k] != needle[k] { hit = 0; k = nl } else { k = k + 1 } }
      if hit == 1 { return 1 }
      i = i + 1
  }
  return 0
37}
38
39// EXACT copy of nx_media_server ms_pathslug -- the slug MUST match the one the open/extract path uses, or the
40// cover dir won't be found. 'b' + 14 hex of an FNV-ish hash of the full NAS path.
41func mc_pathslug(p: *u8, n: i64, out: *u8) -> i64 {
  var h: i64 = MC_MAGIC_1469598103
  var i: i64 = 0
  while i < n { h = (h * 131 + (p[i] as i64)) % MC_MAGIC_72057594037927931; i = i + 1 }
  if h < 0 { h = 0 - h }
  out[0] = 98 as u8
  let tmp: *u8 = sys_mmap(32)
  var k: i64 = 0; var hh: i64 = h
  while k < 14 { tmp[k] = mc_hexc(hh % 16) as u8; hh = hh / 16; k = k + 1 }
  var j: i64 = 0
  while j < 14 { out[1 + j] = tmp[13 - j]; j = j + 1 }
  out[15] = 0 as u8
  return 15
54}
55
56// content-type by extension for the served image (jpg/jpeg/png/gif/webp); octet-stream otherwise.
57func mc_ctype(path: *u8) -> *u8 {
  let n: i64 = mc_slen(path)
  var dot: i64 = 0 - 1; var i: i64 = 0
  while i < n { if path[i] == (46 as u8) { dot = i } i = i + 1 }
  if dot < 0 { return "application/octet-stream" as *u8 }
  let e1: i64 = (path[dot+1] as i64) | 32
  var e2: i64 = 0; if dot + 2 < n { e2 = (path[dot+2] as i64) | 32 }
  var e3: i64 = 0; if dot + 3 < n { e3 = (path[dot+3] as i64) | 32 }
  if e1 == 106 { if e2 == 112 { return "image/jpeg" as *u8 } }              // jp(g/eg)
  if e1 == 112 { if e2 == 110 { if e3 == 103 { return "image/png" as *u8 } } }  // png
  if e1 == 103 { if e2 == 105 { if e3 == 102 { return "image/gif" as *u8 } } }  // gif
  if e1 == 119 { if e2 == 101 { if e3 == 98 { return "image/webp" as *u8 } } }  // web(p)
  return "application/octet-stream" as *u8
70}
71
72// pull the "cover":"<file>" value out of book.json into out (NUL-terminated). returns length (0 if absent).
73func mc_cover_field(jbuf: *u8, jn: i64, out: *u8, cap: i64) -> i64 {
  let key: *u8 = "\"cover\":\"" as *u8
  let kl: i64 = mc_slen(key)
  var i: i64 = 0
  while i + kl <= jn {
      var hit: i64 = 1; var k: i64 = 0
      while k < kl { if jbuf[i+k] != key[k] { hit = 0; k = kl } else { k = k + 1 } }
      if hit == 1 {
          var s: i64 = i + kl; var o: i64 = 0
          while s < jn { if jbuf[s] == (34 as u8) { s = jn } else { if o < cap - 1 { out[o] = jbuf[s]; o = o + 1 } s = s + 1 } }
          out[o] = 0 as u8
          return o
      }
      i = i + 1
  }
  out[0] = 0 as u8
  return 0
90}
91
92// fork the right decoder to extract the cover to reader/<slug>/. epub -> nx_epub_book, mobi/azw/azw3 ->
93// nx_mobi_book (full extraction; cover recorded in book.json). cbz/cbr/cb7 -> nx_cbx_pages --cover
94// (FAST: only the natural-first page image is pulled to <slug>/cover.jpg -- a shelf of comics must not
95// pay a full 100MB unpack per cover request). pdf/fb2 remain text-card fallbacks.
96func mc_extract(path: *u8, pn: i64, slug: *u8) -> i64 {
  var dot: i64 = 0 - 1; var x: i64 = 0
  while x < pn { if path[x] == (46 as u8) { dot = x } x = x + 1 }
  if dot < 0 { return 0 }
  if dot + 3 >= pn { return 0 }
  let e1: i64 = (path[dot+1] as i64) | 32
  let e2: i64 = (path[dot+2] as i64) | 32
  let e3: i64 = (path[dot+3] as i64) | 32
  var ext: *u8 = 0 as *u8
  var coverarg: i64 = 0
  if e1 == 101 { if e2 == 112 { if e3 == 117 { ext = "./_offc/nx_epub_book.elf\x00" as *u8 } } }   // epub
  if e1 == 109 { if e2 == 111 { if e3 == 98 { ext = "./_offc/nx_mobi_book.elf\x00" as *u8 } } }      // mob(i)
  if e1 == 97 { if e2 == 122 { if e3 == 119 { ext = "./_offc/nx_mobi_book.elf\x00" as *u8 } } }      // azw(/azw3)
  if e1 == 99 { if e2 == 98 { ext = "./_offc/nx_cbx_pages.elf\x00" as *u8; coverarg = 1 } }          // cb(z/r/7) -> --cover fast path
  if (ext as i64) == 0 { return 0 }
  let pid: i64 = sys_fork()
  if pid == 0 {
      let av: *i64 = sys_mmap(64) as *i64
      av[0] = ext as i64; av[1] = path as i64; av[2] = slug as i64
      if coverarg == 1 { av[3] = "--cover" as *u8 as i64; av[4] = 0 } else { av[3] = 0 }
      sys_execve(ext, av, 0 as *i64)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(8) as *i64
  sys_wait4(pid, st, 0)
  return 1
122}
123
124// pull the FIRST "file":"<name>" out of cbx.json (pages are natural-sorted, so first = page 0 = the cover).
125func mc_first_page_field(jbuf: *u8, jn: i64, out: *u8, cap: i64) -> i64 {
  let key: *u8 = "\"file\":\"" as *u8
  let kl: i64 = mc_slen(key)
  var i: i64 = 0
  while i + kl <= jn {
      var hit: i64 = 1; var k: i64 = 0
      while k < kl { if jbuf[i+k] != key[k] { hit = 0; k = kl } else { k = k + 1 } }
      if hit == 1 {
          var s: i64 = i + kl; var o: i64 = 0
          while s < jn { if jbuf[s] == (34 as u8) { s = jn } else { if o < cap - 1 { out[o] = jbuf[s]; o = o + 1 } s = s + 1 } }
          out[o] = 0 as u8
          return o
      }
      i = i + 1
  }
  out[0] = 0 as u8
  return 0
142}
143
144// try to resolve a cover for an ALREADY-EXTRACTED slug dir (no forking): 1 = outfull set, 0 = nothing yet.
145// Order: book.json "cover" field -> <slug>/cover.jpg (comic fast-cover) -> cbx.json page 0 (comics + imgbooks).
146func mc_try_resolved(slug: *u8, outfull: *u8) -> i64 {
  let jp: *u8 = sys_mmap(512); var jo: i64 = 0
  jo = mc_apps(jp, jo, MC_READER_ROOT)
  var si: i64 = 0; while slug[si] != (0 as u8) { jp[jo] = slug[si]; jo = jo + 1; si = si + 1 }
  let base: i64 = jo
  // 1) book.json "cover"
  jo = mc_apps(jp, base, "/book.json" as *u8); jp[jo] = 0 as u8
  let lb: *i64 = sys_mmap(8) as *i64
  let jbuf: *u8 = sys_read_file(jp, lb)
  if (jbuf as i64) != 0 {
      let cover: *u8 = sys_mmap(256)
      let cn: i64 = mc_cover_field(jbuf, lb[0], cover, 256)
      if cn > 0 {
          var fo: i64 = 0
          fo = mc_apps(outfull, fo, MC_READER_ROOT)
          var s2: i64 = 0; while slug[s2] != (0 as u8) { outfull[fo] = slug[s2]; fo = fo + 1; s2 = s2 + 1 }
          outfull[fo] = 47 as u8; fo = fo + 1
          var ci: i64 = 0; while cover[ci] != (0 as u8) { outfull[fo] = cover[ci]; fo = fo + 1; ci = ci + 1 }
          outfull[fo] = 0 as u8
          let f1: i64 = sys_openat_rd(outfull)
          if f1 >= 0 { sys_close(f1); return 1 }
      }
  }
  // 2) <slug>/cover.jpg (written by nx_cbx_pages --cover)
  jo = mc_apps(jp, base, "/cover.jpg" as *u8); jp[jo] = 0 as u8
  let f2: i64 = sys_openat_rd(jp)
  if f2 >= 0 {
      sys_close(f2)
      var fo2: i64 = 0; var s3: i64 = 0
      while jp[s3] != (0 as u8) { outfull[fo2] = jp[s3]; fo2 = fo2 + 1; s3 = s3 + 1 }
      outfull[fo2] = 0 as u8
      return 1
  }
  // 3) cbx.json page 0 (an extracted comic / promoted image-book IS its own cover source)
  jo = mc_apps(jp, base, "/cbx.json" as *u8); jp[jo] = 0 as u8
  let lb3: *i64 = sys_mmap(8) as *i64
  let cbuf: *u8 = sys_read_file(jp, lb3)
  if (cbuf as i64) != 0 {
      let pg: *u8 = sys_mmap(256)
      let pn3: i64 = mc_first_page_field(cbuf, lb3[0], pg, 256)
      if pn3 > 0 {
          var fo3: i64 = 0
          fo3 = mc_apps(outfull, fo3, MC_READER_ROOT)
          var s4: i64 = 0; while slug[s4] != (0 as u8) { outfull[fo3] = slug[s4]; fo3 = fo3 + 1; s4 = s4 + 1 }
          outfull[fo3] = 47 as u8; fo3 = fo3 + 1
          var pi: i64 = 0; while pg[pi] != (0 as u8) { outfull[fo3] = pg[pi]; fo3 = fo3 + 1; pi = pi + 1 }
          outfull[fo3] = 0 as u8
          let f3: i64 = sys_openat_rd(outfull)
          if f3 >= 0 { sys_close(f3); return 1 }
      }
  }
  return 0
198}
199
200// resolve a NAS book path -> its on-disk cover image file (extracting on cache-miss).
201//  returns 1 = ok (outfull = cover file path, NUL-terminated); 0 = no cover; -1 = rejected (path traversal).
202//  Resolution order (mc_try_resolved): book.json "cover" -> <slug>/cover.jpg -> cbx.json page 0; one
203//  extraction attempt on cold miss (epub/mobi full decode; cbz/cbr FAST --cover), then re-resolve.
204func mc_cover_resolve(path: *u8, pn: i64, outfull: *u8, cap: i64) -> i64 {
  if mc_contains(path, pn, ".." as *u8) == 1 { return 0 - 1 }
  let slug: *u8 = sys_mmap(32); mc_pathslug(path, pn, slug)
  if mc_try_resolved(slug, outfull) == 1 { return 1 }
  if mc_extract(path, pn, slug) == 0 { return 0 }
  if mc_try_resolved(slug, outfull) == 1 { return 1 }
  return 0
211}
212
213// serve the resolved cover image over an HTTP connection (streamed, with a day of cache). Caller already
214// resolved + authorized. Closes cfd.
215func mc_serve_image(cfd: i64, full: *u8) -> i64 {
  let ct: *u8 = mc_ctype(full)
  let fd: i64 = sys_openat_rd(full)
  if fd < 0 { let d: *u8 = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"; sys_write(cfd, d, mc_slen(d)); sys_close(cfd); return 0 }
  let sz: i64 = sys_lseek(fd, 0, 2); sys_lseek(fd, 0, 0)
  let hdr: *u8 = sys_mmap(256); var h: i64 = 0
  h = mc_apps(hdr, h, "HTTP/1.1 200 OK\r\nContent-Type: " as *u8); h = mc_apps(hdr, h, ct)
  h = mc_apps(hdr, h, "\r\nCache-Control: max-age=86400\r\nContent-Length: " as *u8); h = mc_dec(hdr, h, sz)
  h = mc_apps(hdr, h, "\r\nConnection: close\r\n\r\n" as *u8)
  sys_write(cfd, hdr, h)
  let chunk: *u8 = sys_mmap(MC_MAGIC_262144); var go: i64 = 1
  while go == 1 { let r: i64 = sys_read(fd, chunk, MC_MAGIC_262144); if r <= 0 { go = 0 } else { sys_write(cfd, chunk, r) } }
  sys_close(fd); sys_close(cfd)
  return 0
229}
nx_media_cover_lib.nx source

`nx_media_cover_lib.nx` source
