@noita-ts/wininet 0.0.0-stage → 0.1.0

package/dist/thread.lua

@@ -0,0 +1,382 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
+local __TS__Class = ____lualib.__TS__Class
+local Error = ____lualib.Error
+local RangeError = ____lualib.RangeError
+local ReferenceError = ____lualib.ReferenceError
+local SyntaxError = ____lualib.SyntaxError
+local TypeError = ____lualib.TypeError
+local URIError = ____lualib.URIError
+local __TS__New = ____lualib.__TS__New
+local __TS__ArrayMap = ____lualib.__TS__ArrayMap
+local ____exports = {}
+local ____ffi = require("@noita-ts/ffi")
+local ffi = ____ffi.default
+local ____schema = require("@noita-ts/ffi/schema")
+local c = ____schema.default
+local MAX_ARGS = 8
+ffi.cdef("\n  void* CreateThread(void* attributes, size_t stack_size, void* start, void* param, uint32_t flags, uint32_t* id);\n  int CloseHandle(void* handle);\n  uint32_t GetLastError();\n  void* GetProcessHeap();\n  void* HeapAlloc(void* heap, uint32_t flags, size_t bytes);\n  int HeapFree(void* heap, uint32_t flags, void* mem);\n")
+local C = ffi.C
+--- The thread runs the call.
+local RUNNING = 0
+--- The thread is done; Lua frees the memory of the call.
+local DONE = 1
+--- The pool is released; the thread frees the memory of the call.
+local ABANDONED = 2
+--- `entry` is the thread procedure, `DWORD WINAPI proc(call*)`: it pushes the
+-- arguments, the last one first, calls `fn`, stores its result and the
+-- `GetLastError` of the thread, and swaps `state` to DONE (`xchg` with memory
+-- is atomic, and orders the stores before it). If the state was ABANDONED,
+-- the pool is gone, so the thread frees the `owned` memory and the call itself.
+-- `esp` comes back from `ebp`, so that `fn` can be stdcall or cdecl.
+-- 
+-- `swap_state` is `uint32_t __cdecl swap_state(call*, uint32_t state)`: it
+-- swaps the state of a call atomically and returns the old one, for the Lua
+-- side, which has no atomic operations.
+local CODE = setmetatable(
+    {raw = {
+        85,
+        137,
+        229,
+        83,
+        86,
+        139,
+        93,
+        8,
+        139,
+        75,
+        4,
+        133,
+        201,
+        116,
+        7,
+        255,
+        116,
+        139,
+        4,
+        73,
+        117,
+        249,
+        255,
+        19,
+        137,
+        67,
+        40,
+        255,
+        83,
+        52,
+        137,
+        67,
+        44,
+        141,
+        101,
+        248,
+        184,
+        1,
+        0,
+        0,
+        0,
+        135,
+        67,
+        48,
+        131,
+        248,
+        2,
+        117,
+        31,
+        139,
+        115,
+        64,
+        133,
+        246,
+        116,
+        15,
+        78,
+        255,
+        116,
+        179,
+        68,
+        106,
+        0,
+        255,
+        115,
+        60,
+        255,
+        83,
+        56,
+        235,
+        237,
+        83,
+        106,
+        0,
+        255,
+        115,
+        60,
+        255,
+        83,
+        56,
+        94,
+        91,
+        49,
+        192,
+        93,
+        194,
+        4,
+        0,
+        139,
+        76,
+        36,
+        4,
+        139,
+        68,
+        36,
+        8,
+        135,
+        65,
+        48,
+        195
+    }, vars = {}, labels = {entry = 0, swap_state = 88}},
+    {__call = require("asm_link").link}
+)
+--- A 32-bit FNV-1a hash of `bytes`, as an unsigned decimal number.
+local function hash(bytes)
+    local h = bit.bor(2166136261, 0)
+    for ____, b in ipairs(bytes) do
+        h = bit.bxor(h, b)
+        h = bit.bor(
+            h * 403 + bit.lshift(h, 24),
+            0
+        )
+    end
+    return tostring(h < 0 and h + 4294967296 or h)
+end
+--- A call on a thread. The thread procedure has the offsets of its fields.
+local Call = c.declare(
+    "NoitaTsWininetCall",
+    {
+        c.field("fn", c.voidptr),
+        c.field("argc", c.u32),
+        c.field(
+            "args",
+            c.u32:arr(MAX_ARGS)
+        ),
+        c.field("result", c.u32),
+        c.field("error", c.u32),
+        c.field(
+            "state",
+            c.escape("volatile uint32_t", 4, 4)
+        ),
+        c.field("get_last_error", c.voidptr),
+        c.field("heap_free", c.voidptr),
+        c.field("heap", c.voidptr),
+        c.field("owned_count", c.u32),
+        c.field(
+            "owned",
+            c.voidptr:arr(MAX_ARGS)
+        )
+    }
+)
+local code
+--- The address of the code. The name in the store comes from the bytes of the
+-- code, which also fix the layout of the call, so another version of this
+-- package that changes either one makes its own.
+local function getCode()
+    if code == nil then
+        code = ffi.store.shared(
+            "wininet.proc." .. hash(CODE.raw),
+            function()
+                local mem = ffi.allocExec(#CODE.raw, {persistent = true})
+                __TS__ArrayForEach(
+                    CODE.raw,
+                    function(____, b, i)
+                        mem[i] = b
+                    end
+                )
+                return tonumber(ffi.cast("uint32_t", mem))
+            end
+        )
+    end
+    return code
+end
+local swapState
+--- Swaps the state of `call` atomically, and returns the old one.
+local function swap(call, state)
+    swapState = swapState or ffi.cast(
+        "uint32_t (__cdecl *)(void*, uint32_t)",
+        getCode() + CODE.labels.swap_state
+    )
+    local fn = swapState
+    return fn(
+        ffi.cast("void*", call),
+        state
+    )
+end
+local getLastError = ffi.cast("void*", C.GetLastError)
+local heapFree = ffi.cast("void*", C.HeapFree)
+local processHeap = C.GetProcessHeap()
+local HEAP_ZERO_MEMORY = 8
+--- The address of a pointer, as a key of a table.
+local function address(ptr)
+    return tonumber(ffi.cast("uintptr_t", ptr))
+end
+--- Memory on the process heap and the calls on threads that use it, released
+-- together.
+____exports.Pool = __TS__Class()
+local Pool = ____exports.Pool
+Pool.name = "Pool"
+function Pool.prototype.____constructor(self)
+    self.blocks = {}
+    self.calls = {}
+    self.released = false
+end
+function Pool.prototype.alloc(self, ctype, size)
+    if self.released then
+        error(
+            __TS__New(Error, "the pool is released"),
+            0
+        )
+    end
+    local mem = C.HeapAlloc(processHeap, HEAP_ZERO_MEMORY, size)
+    if mem == nil then
+        error(
+            __TS__New(
+                Error,
+                ("cannot allocate " .. tostring(size)) .. " bytes"
+            ),
+            0
+        )
+    end
+    self.blocks[address(mem)] = mem
+    return ffi.cast(ctype, mem)
+end
+function Pool.prototype.free(self, mem)
+    local key = address(mem)
+    local block = self.blocks[key]
+    if block ~= nil then
+        self.blocks[key] = nil
+        C.HeapFree(processHeap, 0, block)
+    end
+end
+function Pool.prototype.run(self, fn, ...)
+    local args = {...}
+    if #args > MAX_ARGS then
+        error(
+            __TS__New(
+                Error,
+                ("a call on a thread takes at most " .. tostring(MAX_ARGS)) .. " arguments"
+            ),
+            0
+        )
+    end
+    local call = self:alloc(
+        Call:ptr().name,
+        Call.size
+    )
+    call.fn = ffi.cast("void*", fn)
+    call.argc = #args
+    call.get_last_error = getLastError
+    call.heap_free = heapFree
+    call.heap = processHeap
+    local copies = {}
+    local owned = {}
+    __TS__ArrayForEach(
+        args,
+        function(____, arg, i)
+            if type(arg) == "number" then
+                call.args[i] = arg
+            elseif type(arg) == "string" then
+                local copy = self:alloc("char*", #arg + 1)
+                ffi.copy(copy, arg)
+                copies[#copies + 1] = copy
+                owned[#owned + 1] = copy
+                call.args[i] = ffi.cast("uintptr_t", copy)
+            else
+                call.args[i] = ffi.cast("uintptr_t", arg)
+                if self.blocks[address(arg)] ~= nil then
+                    owned[#owned + 1] = arg
+                end
+            end
+        end
+    )
+    __TS__ArrayForEach(
+        owned,
+        function(____, mem, i)
+            call.owned[i] = mem
+        end
+    )
+    call.owned_count = #owned
+    local pending = {
+        abandoned = false,
+        owned = __TS__ArrayMap(
+            owned,
+            function(____, mem) return address(mem) end
+        )
+    }
+    local function done()
+        for ____, copy in ipairs(copies) do
+            self:free(copy)
+        end
+        self:free(call)
+    end
+    local thread = C.CreateThread(
+        nil,
+        0,
+        ffi.cast(
+            "void*",
+            getCode() + CODE.labels.entry
+        ),
+        ffi.cast("void*", call),
+        0,
+        nil
+    )
+    if thread == nil then
+        local ____error = C.GetLastError()
+        done()
+        error(
+            __TS__New(
+                Error,
+                "cannot create a thread: error " .. tostring(____error)
+            ),
+            0
+        )
+    end
+    C.CloseHandle(thread)
+    self.calls[call] = pending
+    while true do
+        if pending.abandoned then
+            error(
+                __TS__New(Error, "the call was cancelled"),
+                0
+            )
+        end
+        if call.state ~= RUNNING then
+            break
+        end
+        coroutine.yield()
+    end
+    self.calls[call] = nil
+    local result = {call.result, call.error}
+    done()
+    return result
+end
+function Pool.prototype.release(self)
+    if self.released then
+        return
+    end
+    self.released = true
+    for call, pending in pairs(self.calls) do
+        pending.abandoned = true
+        if swap(call, ABANDONED) == RUNNING then
+            self.blocks[address(call)] = nil
+            for ____, mem in ipairs(pending.owned) do
+                self.blocks[mem] = nil
+            end
+        end
+    end
+    self.calls = {}
+    for ____, block in pairs(self.blocks) do
+        C.HeapFree(processHeap, 0, block)
+    end
+    self.blocks = {}
+end
+return ____exports

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@noita-ts/wininet",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "An HTTP client for unsafe Noita mods that uses WinINet on native threads, so the game does not stop.",
+  "author": "Anton Bulakh <him@necauq.ua> (https://necauq.ua/)",
+  "license": "MIT",
+  "files": [
+    "dist/**/*.{lua,d.ts}"
+  ],
+  "type": "module",
+  "main": "dist/index",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index"
+    }
+  },
+  "scripts": {
+    "build": "tstl -p .",
+    "prepublishOnly": "rm -rf dist && npm run build"
+  },
+  "dependencies": {
+    "@noita-ts/ffi": "^0.7.0",
+    "@typescript-to-lua/language-extensions": "^1.19.0",
+    "lua-types": "^2.13.1"
+  },
+  "devDependencies": {
+    "@noita-ts/nasm": "^0.1.0",
+    "typescript": "^6.0.2",
+    "typescript-to-lua": "^1.36.0"
+  }
+}

package/readme.md

@@ -0,0 +1,66 @@
+# @noita-ts/wininet
+
+An HTTP client for unsafe [noita-ts](https://github.com/necauqua/noita-ts) mods
+that uses WinINet through the LuaJIT FFI. WinINet is part of Windows (and of
+Wine), so the package ships no DLL. The blocking WinINet calls run on native
+threads, so the game does not stop while a request waits.
+
+## Why
+
+A mod that only makes HTTP requests does not have to ship the pollnet DLL of
+`@noita-ts/pollnet` (3.5 MB) any more. This package is only Lua, and WinINet is
+already on every Windows (and in Wine). Use pollnet when you need its other
+parts, such as WebSockets, TCP or servers.
+
+There is also a bug that WinINet does not have: in Wine (Proton), the HTTPS of
+pollnet (rust `schannel` on the `schannel` of Wine) stops in a response that
+has more than one TLS record (24 KB is enough). It waits until the server
+closes the connection (65 s for nginx), and then it often fails. With WinINet,
+a 1.6 MB download takes about 1 s, with the game running.
+
+## Usage
+
+The API is the same as `HttpClient` of `@noita-ts/pollnet`, so a mod can change
+only the import:
+
+```ts
+import Scheduler from "@noita-ts/base/async";
+import { HttpClient } from "@noita-ts/wininet";
+
+const http = new HttpClient(Scheduler.get());
+
+const response = await http.get("https://example.com/", { Accept: "text/html" });
+print(response.status, response.parseHeaders()["Content-Type"]);
+
+await http.post("https://example.com/api", { "Content-Type": "application/json" }, "{}");
+```
+
+- `new HttpClient(scheduler, options?)`: `scheduler` is anything with
+  `spawn` (a `Scheduler` of `@noita-ts/base/async`). The options are
+  `userAgent` (default `noita-ts/wininet`) and `timeoutMs`, the timeout of a
+  connection, of a send and of a receive (default 30 s). A client keeps a
+  WinINet session until the Lua state is closed, so make one and keep it.
+- `get(url, headers?)` and `post(url, headers?, body?)` resolve to an
+  `HttpResponse` with `status`, `headers` (`Key: value` lines separated by
+  `\n`), `body` and `parseHeaders()`. Headers are a map (an array value
+  sends the header more than once) or a string of `\n`-separated lines. Without
+  headers, a POST sends `content-type: application/x-www-form-urlencoded`, as
+  in pollnet.
+- An error of WinINet rejects the promise with an `Error` that has the method,
+  the URL and the WinINet error, for example
+  `GET http://127.0.0.1:1/: cannot send the request: WinINet error 12029 (cannot connect)`.
+- Redirects are followed, also between http and https.
+
+## Limits
+
+- Only `http` and `https` URLs with a host name or an IPv4 address. Use
+  `127.0.0.1`, not `localhost`: WinINet can take `localhost` as `::1`.
+- The whole body is kept in memory, as one string.
+- Each blocking call starts a new native thread; the Lua side looks at the
+  result once per frame, so every request takes at least a few frames.
+- When the Lua state is closed (for example a new game starts), every client
+  closes its WinINet handles and frees its memory. A request that waits at
+  that moment cannot be stopped in Wine: its thread runs until the call
+  returns or times out, and then frees the memory of the call itself. Windows
+  cancels such a call when its handle is closed.
+- Wine gives a timeout as WinINet error 12030 (connection aborted), not 12002.

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.