@noita-ts/wininet 0.0.0-stage → 0.1.0

package/dist/asm_link.lua

@@ -0,0 +1,47 @@
+-- AUTO-GENERATED by @noita-ts/nasm. Do not edit.
+local M = {}
+local band, rshift = bit.band, bit.rshift
+
+local function add32(bytes, off, value)
+  value = value
+    + bytes[off + 1]
+    + bytes[off + 2] * 0x100
+    + bytes[off + 3] * 0x10000
+    + bytes[off + 4] * 0x1000000
+  bytes[off + 1] = band(value, 0xFF)
+  bytes[off + 2] = band(rshift(value, 8), 0xFF)
+  bytes[off + 3] = band(rshift(value, 16), 0xFF)
+  bytes[off + 4] = band(rshift(value, 24), 0xFF)
+end
+
+function M.link(patch, values)
+  local vars = patch.vars
+  if vars.BASE and not (values and values.BASE) then
+    return function(base)
+      local withBase = { BASE = base }
+      if values then
+        for name, value in pairs(values) do
+          withBase[name] = value
+        end
+      end
+      return M.link(patch, withBase)
+    end
+  end
+  local raw = patch.raw
+  local bytes = { entry = patch.labels.entry or 0 }
+  for i = 1, #raw do
+    bytes[i] = raw[i]
+  end
+  for name, offsets in pairs(vars) do
+    local value = values and values[name]
+    if value == nil then
+      error(string.format("asm: no value given for reloc '%s'", name), 2)
+    end
+    for i = 1, #offsets do
+      add32(bytes, offsets[i], value)
+    end
+  end
+  return bytes
+end
+
+return M

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+/** @noSelfInFile */
+export declare class HttpResponse {
+    status: number;
+    headers: string;
+    body: string;
+    constructor(status: number, headers: string, body: string);
+    /**
+     * Parse the raw header block into a map.
+     * Header names seen more than once collapse into an array of their values, in
+     * order.
+     */
+    parseHeaders(): Record<string, string | string[]>;
+}
+/** The headers of a request: a map, or lines separated by `\n`. */
+export type Headers = Record<string, string | string[]> | string;
+/**
+ * Anything that looks, walks and quacks like a scheduler (to not depend on
+ * `@noita-ts/base` directly).
+ * Import and set up a `Scheduler` from `@noita-ts/base/async` for this.
+ */
+interface Scheduler {
+    spawn<T>(body: () => T): Promise<T>;
+}
+export interface HttpClientOptions {
+    /** The `User-Agent` of the requests. Defaults to `noita-ts/wininet`. */
+    userAgent?: string;
+    /**
+     * The timeout of a connection, of a send and of a receive, in
+     * milliseconds. Defaults to 30 seconds.
+     */
+    timeoutMs?: number;
+}
+/**
+ * An async HTTP client built on top of a {@link Scheduler}.
+ *
+ * Requests run in coroutines and resolve to an {@link HttpResponse}. The
+ * blocking WinINet calls run on native threads, so the game runs while a
+ * request waits.
+ *
+ * A client keeps a WinINet session until the Lua state is closed, so make one
+ * client and keep it. When the state is closed, the client closes its handles
+ * and frees its memory; the thread of a request that still runs frees the
+ * memory of its call when the call ends.
+ */
+export declare class HttpClient {
+    private scheduler;
+    private userAgent;
+    private timeoutMs;
+    private internet;
+    /** The open request and connection handles, with their kinds. */
+    private handles;
+    /** The memory that the threads of the requests use. */
+    private pool;
+    private released;
+    /** Removes the release of this client from the release of the state. */
+    private unregister;
+    constructor(scheduler: Scheduler, options?: HttpClientOptions);
+    /**
+     * Perform an HTTP GET.
+     */
+    get(url: string, headers?: Headers): Promise<HttpResponse>;
+    /**
+     * Perform an HTTP POST with an optional request `body`.
+     *
+     * Without `headers`, the request has
+     * `content-type: application/x-www-form-urlencoded`, as in pollnet.
+     */
+    post(url: string, headers?: Headers, body?: string): Promise<HttpResponse>;
+    /**
+     * Does now what closing the Lua state does: closes the WinINet handles of
+     * the client and frees its memory. A request that runs is abandoned: its
+     * promise rejects, and its thread frees the memory of its call when the call
+     * ends. The client takes no requests after that.
+     *
+     * Only for tests.
+     *
+     * @internal
+     */
+    _release(): void;
+    /** Remembers `handle` until `close`, or until the client is released. */
+    private track;
+    /** Closes a handle of `track`, unless the release closed it already. */
+    private close;
+    /**
+     * The WinINet session of this client, made on first use. It stays open
+     * until the client is released, so that WinINet can keep the connections
+     * alive.
+     */
+    private open;
+    /**
+     * Sets the timeouts of a handle. Wine takes the send and receive timeouts
+     * only from a connection handle, and waits forever without them, so each
+     * connection gets them too.
+     */
+    private setTimeouts;
+    private request;
+    /** Sends the request and reads the response. */
+    private exchange;
+}
+export {};

package/dist/index.lua

@@ -0,0 +1,457 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__StringSlice = ____lualib.__TS__StringSlice
+local __TS__ArrayIsArray = ____lualib.__TS__ArrayIsArray
+local __TS__StringSplit = ____lualib.__TS__StringSplit
+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__StringStartsWith = ____lualib.__TS__StringStartsWith
+local __TS__ObjectKeys = ____lualib.__TS__ObjectKeys
+local __TS__ArraySort = ____lualib.__TS__ArraySort
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local __TS__ArrayMap = ____lualib.__TS__ArrayMap
+local __TS__ArraySlice = ____lualib.__TS__ArraySlice
+local ____exports = {}
+local ____ffi = require("@noita-ts/ffi")
+local ffi = ____ffi.default
+local ____thread = require("thread")
+local Pool = ____thread.Pool
+ffi.cdef("\n  void* InternetOpenA(const char* agent, uint32_t access, const char* proxy, const char* bypass, uint32_t flags);\n  void* InternetConnectA(void* internet, const char* server, uint16_t port, const char* user, const char* password, uint32_t service, uint32_t flags, uintptr_t context);\n  void* HttpOpenRequestA(void* connect, const char* verb, const char* object, const char* version, const char* referrer, const char** accept, uint32_t flags, uintptr_t context);\n  int HttpSendRequestA(void* request, const char* headers, uint32_t headers_length, void* optional, uint32_t optional_length);\n  int InternetSetOptionA(void* internet, uint32_t option, void* buffer, uint32_t length);\n  int InternetReadFile(void* file, void* buffer, uint32_t size, uint32_t* read);\n  int HttpQueryInfoA(void* request, uint32_t info, void* buffer, uint32_t* length, uint32_t* index);\n  int InternetCloseHandle(void* internet);\n  uint32_t GetLastError();\n")
+local wininet = ffi.load("wininet.dll")
+local INTERNET_OPEN_TYPE_PRECONFIG = 0
+local INTERNET_SERVICE_HTTP = 3
+local INTERNET_OPTION_CONNECT_TIMEOUT = 2
+local INTERNET_OPTION_SEND_TIMEOUT = 5
+local INTERNET_OPTION_RECEIVE_TIMEOUT = 6
+local INTERNET_FLAG_RELOAD = 2147483648
+local INTERNET_FLAG_NO_CACHE_WRITE = 67108864
+local INTERNET_FLAG_SECURE = 8388608
+local INTERNET_FLAG_NO_COOKIES = 524288
+local INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP = 32768
+local INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS = 16384
+local INTERNET_FLAG_NO_UI = 512
+local HTTP_QUERY_STATUS_CODE = 19
+local HTTP_QUERY_RAW_HEADERS_CRLF = 22
+local HTTP_QUERY_FLAG_NUMBER = 536870912
+--- The size of one read of the body.
+local CHUNK = 256 * 1024
+--- Names of the common WinINet errors, for the error messages.
+local ERRORS = {
+    [12002] = "timeout",
+    [12005] = "invalid URL",
+    [12006] = "unrecognized scheme",
+    [12007] = "name not resolved",
+    [12029] = "cannot connect",
+    [12030] = "connection aborted",
+    [12031] = "connection reset",
+    [12037] = "certificate date invalid",
+    [12038] = "certificate name invalid",
+    [12045] = "invalid certificate authority",
+    [12057] = "certificate revocation check failed",
+    [12152] = "invalid server response",
+    [12157] = "security channel error",
+    [12169] = "invalid certificate",
+    [12170] = "certificate revoked",
+    [12175] = "decoding failed"
+}
+local function describe(____error)
+    local name = ERRORS[____error]
+    return name ~= nil and ((("WinINet error " .. tostring(____error)) .. " (") .. name) .. ")" or "WinINet error " .. tostring(____error)
+end
+____exports.HttpResponse = __TS__Class()
+local HttpResponse = ____exports.HttpResponse
+HttpResponse.name = "HttpResponse"
+function HttpResponse.prototype.____constructor(self, status, headers, body)
+    self.status = status
+    self.headers = headers
+    self.body = body
+end
+function HttpResponse.prototype.parseHeaders(self)
+    local headers = {}
+    for ____, line in ipairs(__TS__StringSplit(self.headers, "\n")) do
+        do
+            local sep = (string.find(line, ": ", nil, true) or 0) - 1
+            local key = __TS__StringSlice(line, 0, sep)
+            local value = __TS__StringSlice(line, sep + 2)
+            if sep <= 0 or not value then
+                goto __continue5
+            end
+            local prev = headers[key]
+            if not prev then
+                headers[key] = value
+                goto __continue5
+            end
+            if __TS__ArrayIsArray(prev) then
+                prev[#prev + 1] = value
+            else
+                headers[key] = {prev, value}
+            end
+        end
+        ::__continue5::
+    end
+    return headers
+end
+--- A URL, split into the parts that WinINet takes.
+local function parseUrl(url)
+    local scheme, host, port, rest = string.match(url, "^(%a[%w+.-]*)://([^/:?#]+):?(%d*)(.*)$")
+    local ____opt_0 = scheme
+    local lower = ____opt_0 and string.lower(scheme)
+    if lower ~= "http" and lower ~= "https" then
+        error(
+            __TS__New(Error, "not an http or https URL: " .. url),
+            0
+        )
+    end
+    local secure = lower == "https"
+    local path = (string.gsub(rest, "#.*$", ""))
+    if not __TS__StringStartsWith(path, "/") then
+        path = "/" .. path
+    end
+    return {
+        secure = secure,
+        host = host,
+        port = port ~= "" and tonumber(port) or (secure and 443 or 80),
+        path = path
+    }
+end
+--- Headers as WinINet takes them: `Key: value` lines, each ended by CRLF.
+local function formatHeaders(headers)
+    local lines = {}
+    if type(headers) == "string" then
+        for ____, line in ipairs(__TS__StringSplit(headers, "\n")) do
+            lines[#lines + 1] = (string.gsub(line, "\r$", ""))
+        end
+    else
+        local keys = __TS__ObjectKeys(headers)
+        __TS__ArraySort(keys)
+        for ____, key in ipairs(keys) do
+            local value = headers[key]
+            for ____, v in ipairs(type(value) == "string" and ({value}) or value) do
+                lines[#lines + 1] = (key .. ": ") .. v
+            end
+        end
+    end
+    return table.concat(
+        __TS__ArrayMap(
+            __TS__ArrayFilter(
+                lines,
+                function(____, line) return line ~= "" end
+            ),
+            function(____, line) return line .. "\r\n" end
+        ),
+        ""
+    )
+end
+--- The response headers as `HttpResponse` of pollnet has them: `Key: value`
+-- lines separated by `\n`, without the status line.
+local function responseHeaders(raw)
+    local lines = __TS__StringSplit((string.gsub(raw, "\r\n", "\n")), "\n")
+    return table.concat(
+        __TS__ArrayFilter(
+            __TS__ArraySlice(lines, 1),
+            function(____, line) return line ~= "" end
+        ),
+        "\n"
+    )
+end
+--- The kinds of the WinINet handles of a request, children first.
+local REQUEST = 1
+local CONNECT = 2
+--- An async HTTP client built on top of a {@link Scheduler}.
+-- 
+-- Requests run in coroutines and resolve to an {@link HttpResponse}. The
+-- blocking WinINet calls run on native threads, so the game runs while a
+-- request waits.
+-- 
+-- A client keeps a WinINet session until the Lua state is closed, so make one
+-- client and keep it. When the state is closed, the client closes its handles
+-- and frees its memory; the thread of a request that still runs frees the
+-- memory of its call when the call ends.
+____exports.HttpClient = __TS__Class()
+local HttpClient = ____exports.HttpClient
+HttpClient.name = "HttpClient"
+function HttpClient.prototype.____constructor(self, scheduler, options)
+    self.handles = {}
+    self.pool = __TS__New(Pool)
+    self.released = false
+    self.scheduler = scheduler
+    self.userAgent = options and options.userAgent or "noita-ts/wininet"
+    self.timeoutMs = options and options.timeoutMs or 30000
+    self.unregister = ffi.onRelease(function() return self:_release() end)
+end
+function HttpClient.prototype.get(self, url, headers)
+    return self:request("GET", url, headers or "", "")
+end
+function HttpClient.prototype.post(self, url, headers, body)
+    return self:request("POST", url, headers or ({["content-type"] = "application/x-www-form-urlencoded"}), body or "")
+end
+function HttpClient.prototype._release(self)
+    if self.released then
+        return
+    end
+    self.released = true
+    self.unregister()
+    for ____, kind in ipairs({REQUEST, CONNECT}) do
+        for handle, k in pairs(self.handles) do
+            if k == kind then
+                wininet.InternetCloseHandle(handle)
+            end
+        end
+    end
+    self.handles = {}
+    if self.internet ~= nil then
+        wininet.InternetCloseHandle(self.internet)
+        self.internet = nil
+    end
+    self.pool:release()
+end
+function HttpClient.prototype.track(self, handle, kind)
+    if handle ~= nil then
+        self.handles[handle] = kind
+    end
+    return handle
+end
+function HttpClient.prototype.close(self, handle)
+    if self.handles[handle] ~= nil then
+        self.handles[handle] = nil
+        wininet.InternetCloseHandle(handle)
+    end
+end
+function HttpClient.prototype.open(self)
+    if self.released then
+        error(
+            __TS__New(Error, "the client is released"),
+            0
+        )
+    end
+    if self.internet == nil then
+        local internet = wininet.InternetOpenA(
+            self.userAgent,
+            INTERNET_OPEN_TYPE_PRECONFIG,
+            nil,
+            nil,
+            0
+        )
+        if internet == nil then
+            error(
+                __TS__New(
+                    Error,
+                    "cannot open WinINet: " .. describe(ffi.C.GetLastError())
+                ),
+                0
+            )
+        end
+        self:setTimeouts(internet)
+        self.internet = internet
+    end
+    return self.internet
+end
+function HttpClient.prototype.setTimeouts(self, handle)
+    local timeout = ffi.new("uint32_t[1]", self.timeoutMs)
+    for ____, option in ipairs({INTERNET_OPTION_CONNECT_TIMEOUT, INTERNET_OPTION_SEND_TIMEOUT, INTERNET_OPTION_RECEIVE_TIMEOUT}) do
+        wininet.InternetSetOptionA(handle, option, timeout, 4)
+    end
+end
+function HttpClient.prototype.request(self, method, url, headers, body)
+    return self.scheduler:spawn(function()
+        local ____parseUrl_result_6 = parseUrl(url)
+        local secure = ____parseUrl_result_6.secure
+        local host = ____parseUrl_result_6.host
+        local port = ____parseUrl_result_6.port
+        local path = ____parseUrl_result_6.path
+        local function fail(what, ____error)
+            error(
+                __TS__New(
+                    Error,
+                    (((((method .. " ") .. url) .. ": ") .. what) .. ": ") .. describe(____error)
+                ),
+                0
+            )
+        end
+        local connect = self:track(
+            wininet.InternetConnectA(
+                self:open(),
+                host,
+                port,
+                nil,
+                nil,
+                INTERNET_SERVICE_HTTP,
+                0,
+                0
+            ),
+            CONNECT
+        )
+        if connect == nil then
+            fail(
+                "cannot connect",
+                ffi.C.GetLastError()
+            )
+        end
+        do
+            local ____try, ____hasReturned, ____returnValue = pcall(function()
+                self:setTimeouts(connect)
+                local flags = bit.bor(
+                    bit.bor(
+                        bit.bor(
+                            bit.bor(
+                                bit.bor(INTERNET_FLAG_RELOAD, INTERNET_FLAG_NO_CACHE_WRITE),
+                                INTERNET_FLAG_NO_COOKIES
+                            ),
+                            INTERNET_FLAG_NO_UI
+                        ),
+                        INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP
+                    ),
+                    INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS
+                )
+                if secure then
+                    flags = bit.bor(flags, INTERNET_FLAG_SECURE)
+                end
+                local request = self:track(
+                    wininet.HttpOpenRequestA(
+                        connect,
+                        method,
+                        path,
+                        nil,
+                        nil,
+                        nil,
+                        flags,
+                        0
+                    ),
+                    REQUEST
+                )
+                if request == nil then
+                    fail(
+                        "cannot open the request",
+                        ffi.C.GetLastError()
+                    )
+                end
+                do
+                    local ____try, ____hasReturned, ____returnValue = pcall(function()
+                        return true, self:exchange(request, headers, body, fail)
+                    end)
+                    do
+                        self:close(request)
+                    end
+                    if not ____try then
+                        error(____hasReturned, 0)
+                    end
+                    if ____try and ____hasReturned then
+                        return true, ____returnValue
+                    end
+                end
+            end)
+            do
+                self:close(connect)
+            end
+            if not ____try then
+                error(____hasReturned, 0)
+            end
+            if ____try and ____hasReturned then
+                return ____returnValue
+            end
+        end
+    end)
+end
+function HttpClient.prototype.exchange(self, request, headers, body, fail)
+    local formatted = formatHeaders(headers)
+    local sent, sendError = unpack(
+        self.pool:run(
+            wininet.HttpSendRequestA,
+            request,
+            formatted ~= "" and formatted or 0,
+            #formatted,
+            body ~= "" and body or 0,
+            #body
+        ),
+        1,
+        2
+    )
+    if sent == 0 then
+        fail("cannot send the request", sendError)
+    end
+    local status = ffi.new("uint32_t[1]")
+    local length = ffi.new("uint32_t[1]", 4)
+    if wininet.HttpQueryInfoA(
+        request,
+        bit.bor(HTTP_QUERY_STATUS_CODE, HTTP_QUERY_FLAG_NUMBER),
+        status,
+        length,
+        nil
+    ) == 0 then
+        fail(
+            "no status in the response",
+            ffi.C.GetLastError()
+        )
+    end
+    length[0] = 0
+    wininet.HttpQueryInfoA(
+        request,
+        HTTP_QUERY_RAW_HEADERS_CRLF,
+        nil,
+        length,
+        nil
+    )
+    local raw = ""
+    if length[0] > 0 then
+        local buffer = ffi.new("char[?]", length[0] + 1)
+        if wininet.HttpQueryInfoA(
+            request,
+            HTTP_QUERY_RAW_HEADERS_CRLF,
+            buffer,
+            length,
+            nil
+        ) == 0 then
+            fail(
+                "cannot read the response headers",
+                ffi.C.GetLastError()
+            )
+        end
+        raw = ffi.string(buffer, length[0])
+    end
+    local buffer = self.pool:alloc("uint8_t*", CHUNK)
+    local read = self.pool:alloc("uint32_t*", 4)
+    local parts = {}
+    do
+        local ____try, ____error = pcall(function()
+            while true do
+                local ok, ____error = unpack(
+                    self.pool:run(
+                        wininet.InternetReadFile,
+                        request,
+                        buffer,
+                        CHUNK,
+                        read
+                    ),
+                    1,
+                    2
+                )
+                if ok == 0 then
+                    fail("cannot read the response", ____error)
+                end
+                if read[0] == 0 then
+                    break
+                end
+                parts[#parts + 1] = ffi.string(buffer, read[0])
+            end
+        end)
+        do
+            self.pool:free(buffer)
+            self.pool:free(read)
+        end
+        if not ____try then
+            error(____error, 0)
+        end
+    end
+    return __TS__New(
+        ____exports.HttpResponse,
+        status[0],
+        responseHeaders(raw),
+        table.concat(parts, "")
+    )
+end
+return ____exports