@scriptc/runtime 0.0.25 → 0.0.26

package/src/scr_lib.c

@@ -175,6 +175,8 @@ ScrStr *scr_process_platform(void) {
     scr_platform_str = scr_str_new("darwin", 6);
 #elif defined(__linux__)
     scr_platform_str = scr_str_new("linux", 5);
+#elif defined(__wasi__)
+    scr_platform_str = scr_str_new("wasi", 4);
 #elif defined(_WIN32)
     scr_platform_str = scr_str_new("win32", 5);
 #else
@@ -188,7 +190,11 @@ ScrStr *scr_process_platform(void) {
  * Node spells its own build's arch. Interned like process.platform. */
 ScrStr *scr_process_arch(void) {
   if (!scr_arch_str) {
-#if defined(__aarch64__) || defined(_M_ARM64)
+#if defined(__wasm32__)
+    scr_arch_str = scr_str_new("wasm32", 6);
+#elif defined(__wasm64__)
+    scr_arch_str = scr_str_new("wasm64", 6);
+#elif defined(__aarch64__) || defined(_M_ARM64)
     scr_arch_str = scr_str_new("arm64", 5);
 #elif defined(__x86_64__) || defined(_M_X64)
     scr_arch_str = scr_str_new("x64", 3);
@@ -350,11 +356,11 @@ ScrArr *scr_env_pairs(void) {
 
 double scr_process_pid(void) { return (double)getpid(); }
 
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
 /* No uids/gids exist on Windows: Node's process object simply has no
  * getuid/getgid members there, so a call is the property-access TypeError
  * below — thrown catchably, exactly what `process.getuid()` does under
- * Windows Node. */
+ * Windows Node. WASI has no uid/gid process model either. */
 double scr_process_getuid(void) {
   scr_throw_error_msg(SCR_ERR_TYPE, "process.getuid is not a function", 32);
   return 0;
@@ -532,6 +538,14 @@ static int scr_win_kill(int pid, int sig) {
   return 0;
 }
 #define scr_sys_kill(pid, sig) scr_win_kill((int)(pid), (sig))
+#elif defined(__wasi__)
+static int scr_wasi_kill(int pid, int sig) {
+  (void)pid;
+  (void)sig;
+  errno = ENOSYS;
+  return -1;
+}
+#define scr_sys_kill(pid, sig) scr_wasi_kill((int)(pid), (sig))
 #else
 #define scr_sys_kill(pid, sig) kill((pid_t)(pid), (sig))
 #endif
@@ -689,6 +703,27 @@ ScrStr *scr_os_tmpdir(void) {
   if (len > 1 && (buf[len - 1] == '\\' || buf[len - 1] == '/')) len--;
   return scr_str_new(buf, len);
 }
+#elif defined(__wasi__)
+/* WASI has an inherited environment but no passwd database, uname, or
+ * physical-memory query. Keep the useful environment-backed answers and
+ * spell the platform explicitly for the rest. */
+ScrStr *scr_os_homedir(void) {
+  const char *home = getenv("HOME");
+  return scr_str_new(home ? home : "", home ? strlen(home) : 0);
+}
+ScrStr *scr_os_user_name(void) {
+  const char *user = getenv("USER");
+  return scr_str_new(user ? user : "", user ? strlen(user) : 0);
+}
+ScrStr *scr_os_user_shell(void) { return scr_str_new("", 0); }
+ScrStr *scr_os_user_homedir(void) { return scr_os_homedir(); }
+ScrStr *scr_os_release(void) { return scr_str_new("", 0); }
+ScrStr *scr_os_type(void) { return scr_str_new("WASI", 4); }
+double scr_os_totalmem(void) { return 0; }
+/* The guest temp namespace is stable across hosts. `scriptc run` preopens
+ * the host's /tmp at this path; other WASI hosts can provide the same
+ * capability without leaking a host-specific TMPDIR into the module. */
+ScrStr *scr_os_tmpdir(void) { return scr_str_new("/tmp", 4); }
 #else
 ScrStr *scr_os_homedir(void) {
   /* uv_os_homedir: $HOME when set (even empty is "set" only if non-NULL;
@@ -1226,7 +1261,7 @@ double scr_thread_cpu_system_diff(double prev) { return scr_thread_cpu_system()
  * Darwin's bytes by 1024; the rest are getrusage's own counters, zero
  * where the platform never fills them). */
 double scr_process_rusage(double idx) {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   /* uv fills only the CPU times and page-fault/maxRSS slice on Windows;
    * everything else answers 0 — Node's own shape there. */
   switch ((int)idx) {
@@ -1336,6 +1371,11 @@ double scr_process_umask(double mask) {
     _umask_s((int)mask, &prev);
   }
   return (double)prev;
+#elif defined(__wasi__)
+  static mode_t current = 022;
+  mode_t prev = current;
+  if (mask >= 0) current = (mode_t)mask;
+  return (double)prev;
 #else
   mode_t prev;
   if (mask < 0) {
@@ -1653,9 +1693,10 @@ void scr_fs_chmod(ScrStr *path, double mode) {
 }
 
 void scr_fs_chown(ScrStr *path, double uid, double gid) {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   /* libuv's uv_fs_chown on Windows is an unconditional no-op success —
-   * Node's chownSync "works" and changes nothing there; same here. */
+   * Node's chownSync "works" and changes nothing there; WASI likewise has
+   * no ownership model. */
   (void)path; (void)uid; (void)gid;
 #else
   /* Node passes the ids straight to chown(2); -1 is the POSIX "leave
@@ -1863,7 +1904,7 @@ static bool scr_fs_write_fd_valid(double fd) {
  * call, preserving any signal that was already pending. */
 static ssize_t scr_fs_write_once(int fd, const void *data, size_t length,
                                  bool positioned, double position) {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__wasi__)
   return positioned
     ? scr_fs_pwrite(fd, data, length, position)
     : write(fd, data, length);
@@ -2520,23 +2561,23 @@ void scr_fs_rm_opts_retry(ScrStr *path, bool recursive, bool force, double max_r
   scr_str_release(f.path);
 }
 
-#ifdef _WIN32
-/* No mkdtemp in the CRT: libuv's own fallback shape — six random
+#if defined(_WIN32) || defined(__wasi__)
+/* No mkdtemp in the Windows CRT or WASI libc: libuv's own fallback shape — six random
  * [a-z0-9] name characters from the CSPRNG, retried on EEXIST. */
-static char *scr_win_mkdtemp(char *tmpl) {
+static char *scr_portable_mkdtemp(char *tmpl) {
   static const char cs[] = "abcdefghijklmnopqrstuvwxyz0123456789";
   size_t len = strlen(tmpl);
   for (int tries = 0; tries < 32; tries++) {
     unsigned char r[6];
     arc4random_buf(r, sizeof r);
     for (size_t i = 0; i < 6; i++) tmpl[len - 6 + i] = cs[r[i] % 36];
-    if (mkdir(tmpl) == 0) return tmpl;
+    if (scr_sys_mkdir(tmpl, 0777) == 0) return tmpl;
     if (errno != EEXIST) break;
   }
   memcpy(tmpl + len - 6, "XXXXXX", 6); /* the error message shows the template */
   return NULL;
 }
-#define mkdtemp scr_win_mkdtemp
+#define mkdtemp scr_portable_mkdtemp
 #endif
 
 ScrStr *scr_fs_mkdtemp(ScrStr *prefix) {
@@ -2688,6 +2729,8 @@ double scr_process_columns(double fd) {
   CONSOLE_SCREEN_BUFFER_INFO info;
   if (h == INVALID_HANDLE_VALUE || !GetConsoleScreenBufferInfo(h, &info)) return -1;
   return (double)(info.srWindow.Right - info.srWindow.Left + 1);
+#elif defined(__wasi__)
+  return -1;
 #else
   struct winsize ws;
   if (ioctl((int)fd, TIOCGWINSZ, &ws) != 0) return -1;
@@ -2728,6 +2771,12 @@ void scr_process_stdin_set_raw_mode(bool raw) {
     (void)SetConsoleMode(h, scr_stdin_cooked);
   }
 }
+#elif defined(__wasi__)
+void scr_process_stdin_set_raw_mode(bool raw) {
+  (void)raw;
+  const char msg[] = "process.stdin.setRawMode is not a function";
+  scr_throw_error_msg(SCR_ERR_TYPE, msg, sizeof msg - 1);
+}
 #else
 static struct termios scr_stdin_cooked;
 static bool scr_stdin_cooked_saved = false;

package/src/scr_musl.c

@@ -0,0 +1,274 @@
+/* musl libc shim — compiled into linux-musl target builds only (cc.ts adds
+ * this TU together with -DSCR_MUSL). musl deliberately provides no libc
+ * identification macro, so the target-selected project macro is the guard.
+ *
+ * The x86_64 ucontext implementation below is derived from libucontext
+ * commit 49e671dd52ff6791295d8161ad3b6da7dc5f6f9d:
+ * https://github.com/kaniini/libucontext
+ *
+ * Copyright (c) 2018-2025 Ariadne Conill <ariadne@dereferenced.org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * This software is provided 'as is' and without any warranty, express or
+ * implied. In no event shall the authors be liable for any damages arising
+ * from the use of this software. */
+#ifdef SCR_MUSL
+
+#include "scr_runtime.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/random.h>
+#ifndef SCR_LIB
+#include <stdarg.h>
+#include <ucontext.h>
+#endif
+
+#if !defined(__x86_64__)
+#error "scriptc's musl runtime currently supports x86_64 only"
+#endif
+
+/* The scriptc runtime uses arc4random_buf as its infallible CSPRNG contract.
+ * Linux getrandom has the same kernel source and needs neither mutable state
+ * nor an fd. Retry interrupts and short reads; any other failure enters the
+ * runtime trap funnel rather than returning predictable or partially
+ * initialized bytes. Executables still print and abort there, while library
+ * artifacts deliver the failure to their registered panic sink. */
+void arc4random_buf(void *buf, size_t n) {
+  unsigned char *p = buf;
+  while (n > 0) {
+    ssize_t got = getrandom(p, n, 0);
+    if (got > 0) {
+      p += (size_t)got;
+      n -= (size_t)got;
+      continue;
+    }
+    if (got < 0 && errno == EINTR) continue;
+    scr_trap("scriptc: getrandom failed\n");
+  }
+}
+
+/* Library artifacts contain no fibers or event loop, so they need only the
+ * CSPRNG shim above and must not acquire context-switching definitions. */
+#ifndef SCR_LIB
+
+/* musl exposes the POSIX ucontext types but intentionally omits these legacy
+ * functions. scriptc's async/generator fibers need only user-space register
+ * swaps; they never use a context to mutate the process signal mask. This is
+ * libucontext's fast (non-POSIX-signal-mask) x86_64 implementation, emitted
+ * under the standard symbol names that musl leaves unresolved. */
+_Static_assert(offsetof(ucontext_t, uc_mcontext.gregs) == 40,
+               "unexpected musl x86_64 ucontext layout");
+_Static_assert(offsetof(ucontext_t, uc_mcontext.fpregs) == 224,
+               "unexpected musl x86_64 fpregs layout");
+_Static_assert(offsetof(ucontext_t, __fpregs_mem) == 424,
+               "unexpected musl x86_64 fpregs storage layout");
+
+/* Keep the assembler independent of whether the sysroot exposes glibc's
+ * REG_* spellings as enum constants, self-referential macros, or neither. */
+#undef REG_R8
+#undef REG_R9
+#undef REG_R10
+#undef REG_R11
+#undef REG_R12
+#undef REG_R13
+#undef REG_R14
+#undef REG_R15
+#undef REG_RDI
+#undef REG_RSI
+#undef REG_RBP
+#undef REG_RBX
+#undef REG_RDX
+#undef REG_RAX
+#undef REG_RCX
+#undef REG_RSP
+#undef REG_RIP
+#define REG_R8 0
+#define REG_R9 1
+#define REG_R10 2
+#define REG_R11 3
+#define REG_R12 4
+#define REG_R13 5
+#define REG_R14 6
+#define REG_R15 7
+#define REG_RDI 8
+#define REG_RSI 9
+#define REG_RBP 10
+#define REG_RBX 11
+#define REG_RDX 12
+#define REG_RAX 13
+#define REG_RCX 14
+#define REG_RSP 15
+#define REG_RIP 16
+
+#define SCR_STR_INNER(x) #x
+#define SCR_STR(x) SCR_STR_INNER(x)
+#define SCR_UC_GREG(reg) (40 + ((reg) * 8))
+
+__asm__(
+    ".text\n"
+    ".global getcontext\n"
+    "getcontext:\n"
+    "  movq %r8, "  SCR_STR(SCR_UC_GREG(REG_R8))  "(%rdi)\n"
+    "  movq %r9, "  SCR_STR(SCR_UC_GREG(REG_R9))  "(%rdi)\n"
+    "  movq %r10, " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rdi)\n"
+    "  movq %r11, " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rdi)\n"
+    "  movq %r12, " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rdi)\n"
+    "  movq %r13, " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rdi)\n"
+    "  movq %r14, " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rdi)\n"
+    "  movq %r15, " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rdi)\n"
+    "  movq %rdi, " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rdi)\n"
+    "  movq %rsi, " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rdi)\n"
+    "  movq %rbp, " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rdi)\n"
+    "  movq %rbx, " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rdi)\n"
+    "  movq %rdx, " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rdi)\n"
+    "  movq %rax, " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rdi)\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rdi)\n"
+    "  movq (%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rdi)\n"
+    "  leaq 8(%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rdi)\n"
+    "  leaq 424(%rdi), %rcx\n"
+    "  movq %rcx, 224(%rdi)\n"
+    "  fnstenv (%rcx)\n"
+    "  fldenv (%rcx)\n"
+    "  stmxcsr 448(%rdi)\n"
+    "  xorl %eax, %eax\n"
+    "  ret\n"
+
+    ".global setcontext\n"
+    "setcontext:\n"
+    "  movq 224(%rdi), %rcx\n"
+    "  fldenv (%rcx)\n"
+    "  ldmxcsr 448(%rdi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R8))  "(%rdi), %r8\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R9))  "(%rdi), %r9\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rdi), %r10\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rdi), %r11\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rdi), %r12\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rdi), %r13\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rdi), %r14\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rdi), %r15\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rdi), %rsi\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rdi), %rbp\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rdi), %rbx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rdi), %rdx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rdi), %rax\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rdi), %rcx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rdi), %rsp\n"
+    "  pushq " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rdi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rdi), %rdi\n"
+    "  xorl %eax, %eax\n"
+    "  ret\n"
+
+    ".global swapcontext\n"
+    "swapcontext:\n"
+    "  movq %r8, "  SCR_STR(SCR_UC_GREG(REG_R8))  "(%rdi)\n"
+    "  movq %r9, "  SCR_STR(SCR_UC_GREG(REG_R9))  "(%rdi)\n"
+    "  movq %r10, " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rdi)\n"
+    "  movq %r11, " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rdi)\n"
+    "  movq %r12, " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rdi)\n"
+    "  movq %r13, " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rdi)\n"
+    "  movq %r14, " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rdi)\n"
+    "  movq %r15, " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rdi)\n"
+    "  movq %rdi, " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rdi)\n"
+    "  movq %rsi, " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rdi)\n"
+    "  movq %rbp, " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rdi)\n"
+    "  movq %rbx, " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rdi)\n"
+    "  movq %rdx, " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rdi)\n"
+    "  movq %rax, " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rdi)\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rdi)\n"
+    "  movq (%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rdi)\n"
+    "  leaq 8(%rsp), %rcx\n"
+    "  movq %rcx, " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rdi)\n"
+    "  leaq 424(%rdi), %rcx\n"
+    "  movq %rcx, 224(%rdi)\n"
+    "  fnstenv (%rcx)\n"
+    "  fldenv (%rcx)\n"
+    "  stmxcsr 448(%rdi)\n"
+    "  movq 224(%rsi), %rcx\n"
+    "  fldenv (%rcx)\n"
+    "  ldmxcsr 448(%rsi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R8))  "(%rsi), %r8\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R9))  "(%rsi), %r9\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R10)) "(%rsi), %r10\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R11)) "(%rsi), %r11\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R12)) "(%rsi), %r12\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R13)) "(%rsi), %r13\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R14)) "(%rsi), %r14\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_R15)) "(%rsi), %r15\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDI)) "(%rsi), %rdi\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBP)) "(%rsi), %rbp\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RBX)) "(%rsi), %rbx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RDX)) "(%rsi), %rdx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RAX)) "(%rsi), %rax\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RCX)) "(%rsi), %rcx\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSP)) "(%rsi), %rsp\n"
+    "  pushq " SCR_STR(SCR_UC_GREG(REG_RIP)) "(%rsi)\n"
+    "  movq " SCR_STR(SCR_UC_GREG(REG_RSI)) "(%rsi), %rsi\n"
+    "  xorl %eax, %eax\n"
+    "  ret\n"
+
+    ".hidden scr_musl_context_trampoline\n"
+    "scr_musl_context_trampoline:\n"
+    "  movq (%rbx), %rdi\n"
+    "  testq %rdi, %rdi\n"
+    "  je 1f\n"
+    "  call setcontext\n"
+    "  ud2\n"
+    "1:\n"
+    "  xorl %edi, %edi\n"
+    "  call exit\n"
+    "  ud2\n");
+
+extern void scr_musl_context_trampoline(void);
+
+void makecontext(ucontext_t *ucp, void (*func)(void), int argc, ...) {
+  greg_t *sp;
+  va_list va;
+  int i;
+  unsigned int link_slot = (unsigned int)(argc > 6 ? argc - 6 : 0) + 1;
+
+  sp = (greg_t *)((uintptr_t)ucp->uc_stack.ss_sp + ucp->uc_stack.ss_size);
+  sp -= link_slot;
+  sp = (greg_t *)(((uintptr_t)sp & ~(uintptr_t)15) - 8);
+
+  ucp->uc_mcontext.fpregs = (void *)&ucp->__fpregs_mem;
+  ucp->uc_mcontext.gregs[REG_RIP] = (greg_t)(uintptr_t)func;
+  ucp->uc_mcontext.gregs[REG_RBX] = (greg_t)(uintptr_t)&sp[link_slot];
+  ucp->uc_mcontext.gregs[REG_RSP] = (greg_t)(uintptr_t)sp;
+
+  sp[0] = (greg_t)(uintptr_t)&scr_musl_context_trampoline;
+  sp[link_slot] = (greg_t)(uintptr_t)ucp->uc_link;
+
+  va_start(va, argc);
+  for (i = 0; i < argc; i++) {
+    greg_t arg = va_arg(va, greg_t);
+    switch (i) {
+      case 0: ucp->uc_mcontext.gregs[REG_RDI] = arg; break;
+      case 1: ucp->uc_mcontext.gregs[REG_RSI] = arg; break;
+      case 2: ucp->uc_mcontext.gregs[REG_RDX] = arg; break;
+      case 3: ucp->uc_mcontext.gregs[REG_RCX] = arg; break;
+      case 4: ucp->uc_mcontext.gregs[REG_R8] = arg; break;
+      case 5: ucp->uc_mcontext.gregs[REG_R9] = arg; break;
+      default: sp[i - 5] = arg; break;
+    }
+  }
+  va_end(va);
+}
+
+#undef SCR_UC_GREG
+#undef SCR_STR
+#undef SCR_STR_INNER
+
+#endif /* !SCR_LIB */
+
+#else /* !SCR_MUSL */
+
+typedef int scr_musl_unused;
+
+#endif /* SCR_MUSL */

package/src/scr_net.c

@@ -389,6 +389,16 @@ struct ScrNetServer {
   bool closing;       /* close() called; 'close' fires when conns drain */
   bool close_emitted; /* settled: off the registry, listeners dropped */
   bool emit_listening;
+  /* The writable http.Server timeout property values. Kept on the shared
+   * server handle because http/https servers retain that handle identity;
+   * plain net servers never expose these fields through the static type
+   * surface. Indices match lower-server.ts's selector ABI. */
+  double http_timeouts[5];
+  /* A dynamic write may store any JS value on these ordinary writable
+   * properties. Numeric writes stay in http_timeouts; every other value
+   * is retained here so dynamic reads preserve kind and identity. */
+  ScrDyn *http_timeout_dyn[5];
+  bool http_timeout_surface; /* true only for HTTP/1 and HTTPS servers */
   bool defer_conn; /* TLS: 'connection' fires post-handshake, not at accept */
   bool bound_v6;       /* the bound family (address()'s 'IPv6'/'IPv4' split) */
   ScrStr *bound_host;  /* the explicit bind host (NULL = the host-less any:
@@ -556,6 +566,7 @@ void scr_net_server_release(ScrNetServer *s) {
     scr_net_ls_drop(&s->close_ls);
     scr_net_ls_drop(&s->listening_cbs);
     scr_closure_release(s->close_override);
+    for (size_t i = 0; i < 5; i++) scr_dyn_release(s->http_timeout_dyn[i]);
     scr_str_release(s->bound_host);
     scr_str_release(s->pending_err);
     if (s->fd >= 0) scr_net_close_fd_raw(s->fd);
@@ -1200,6 +1211,11 @@ static ScrNetServer *scr_net_server_new(void) {
   s->kind = SCR_NET_K_SERVER;
   s->rc = 1;
   s->fd = -1;
+  s->http_timeouts[0] = 0;      /* timeout */
+  s->http_timeouts[1] = 5000;   /* keepAliveTimeout */
+  s->http_timeouts[2] = 60000;  /* headersTimeout */
+  s->http_timeouts[3] = 300000; /* requestTimeout */
+  s->http_timeouts[4] = 1000;   /* keepAliveTimeoutBuffer */
 #ifdef SCR_RC_AUDIT
   scr_net_live++;
 #endif
@@ -1378,6 +1394,79 @@ void scr_net_listen_opts(ScrNetServer *s, double port, ScrStr *host /*borrowed*/
 
 double scr_net_server_port(ScrNetServer *s) { return (double)s->port; }
 
+double scr_net_server_timeout_get(ScrNetServer *s, double field) {
+  static const char *const names[] = {
+    "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout",
+    "keepAliveTimeoutBuffer",
+  };
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  if (s->http_timeout_dyn[i] != NULL) {
+    scr_dyn_arg_type_fail(names[i], "of type number", s->http_timeout_dyn[i]);
+    return 0; /* pending exception; typed reads validate an any-written value */
+  }
+  return s->http_timeouts[i];
+}
+
+void scr_net_server_timeout_set(ScrNetServer *s, double field, double value) {
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  scr_dyn_release(s->http_timeout_dyn[i]);
+  s->http_timeout_dyn[i] = NULL;
+  s->http_timeouts[i] = value;
+}
+
+void scr_net_server_enable_http_timeout_surface(ScrNetServer *s) {
+  s->http_timeout_surface = true;
+}
+
+/* Constructor-option validation is intentionally separate from the plain
+ * writable-property setter above. Node validates these option values as
+ * non-negative safe integers, while later property assignments store the
+ * number directly. */
+bool scr_net_server_timeout_option_check(double field, double value) {
+  static const char *const names[] = {
+    "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout",
+    "keepAliveTimeoutBuffer",
+  };
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  char recv[48], msg[224];
+  if (!(isfinite(value) && trunc(value) == value)) {
+    scr_num_received(value, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be an integer. Received %s",
+                       names[i], recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  if (value < 0 || value > 9007199254740991.0) {
+    scr_num_received(value, recv);
+    int len = snprintf(msg, sizeof msg,
+                       "The value of \"%s\" is out of range. It must be >= 0 && <= 9007199254740991. Received %s",
+                       names[i], recv);
+    scr_throw_error_msg_code(SCR_ERR_RANGE, msg, (size_t)len, "ERR_OUT_OF_RANGE");
+    return false;
+  }
+  return true;
+}
+
+void scr_net_server_timeout_option_set(ScrNetServer *s, double field, const ScrDyn *value) {
+  int i = (int)field;
+  if (i < 0 || i >= 5) abort(); /* compiler/runtime ABI violation */
+  if (value->kind == SCR_DYN_UNDEF) return; /* optional field is absent */
+  if (value->kind != SCR_DYN_NUM) {
+    static const char *const names[] = {
+      "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout",
+      "keepAliveTimeoutBuffer",
+    };
+    scr_dyn_arg_type_fail(names[i], "of type number", value);
+    return;
+  }
+  if (!scr_net_server_timeout_option_check(field, value->v.num)) return;
+  scr_net_server_timeout_set(s, field, value->v.num);
+}
+
 /* address()'s other two fields — the bound host ('::'/'0.0.0.0' for the
  * host-less any, the normalized explicit host otherwise) and the family
  * string. Answer the any-form defaults before listen (Node answers null
@@ -3299,13 +3388,28 @@ static ScrDyn *scr_net_dynh_srv_invoke(void *h, ScrDyn *self, const char *method
   return NULL;
 }
 
+static int scr_net_dynh_srv_timeout_field(const char *key) {
+  if (strcmp(key, "timeout") == 0) return 0;
+  if (strcmp(key, "keepAliveTimeout") == 0) return 1;
+  if (strcmp(key, "headersTimeout") == 0) return 2;
+  if (strcmp(key, "requestTimeout") == 0) return 3;
+  if (strcmp(key, "keepAliveTimeoutBuffer") == 0) return 4;
+  return -1;
+}
+
 static ScrDyn *scr_net_dynh_srv_get(void *h, const char *key, size_t key_len) {
   ScrNetServer *s = (ScrNetServer *)h;
   (void)key_len;
   if (strcmp(key, "listening") == 0) return scr_dyn_new_bool(s->listening);
+  int timeout_field = scr_net_dynh_srv_timeout_field(key);
+  if (timeout_field >= 0 && s->http_timeout_surface) {
+    if (s->http_timeout_dyn[timeout_field] != NULL) {
+      return scr_dyn_retain(s->http_timeout_dyn[timeout_field]);
+    }
+    return scr_dyn_new_num(scr_net_server_timeout_get(s, (double)timeout_field));
+  }
   {
-    static const char *const known[] = { "maxConnections", "connections", "maxHeadersCount",
-      "timeout", "keepAliveTimeout", "headersTimeout", "requestTimeout", NULL };
+    static const char *const known[] = { "maxConnections", "connections", "maxHeadersCount", NULL };
     for (size_t i = 0; known[i]; i++) {
       if (strcmp(key, known[i]) == 0) {
         scr_net_dynh_srv_unsupported(key, NULL);
@@ -3317,7 +3421,18 @@ static ScrDyn *scr_net_dynh_srv_get(void *h, const char *key, size_t key_len) {
 }
 
 static bool scr_net_dynh_srv_set(void *h, const char *key, size_t key_len, const ScrDyn *value) {
-  (void)h; (void)key; (void)key_len; (void)value;
+  ScrNetServer *s = (ScrNetServer *)h;
+  (void)key_len;
+  int timeout_field = scr_net_dynh_srv_timeout_field(key);
+  if (timeout_field >= 0 && s->http_timeout_surface) {
+    if (value->kind == SCR_DYN_NUM) {
+      scr_net_server_timeout_set(s, (double)timeout_field, value->v.num);
+    } else {
+      scr_dyn_release(s->http_timeout_dyn[timeout_field]);
+      s->http_timeout_dyn[timeout_field] = scr_dyn_retain((ScrDyn *)value);
+    }
+    return true;
+  }
   return false;
 }