quickwin 3.0.0 → 3.0.2

package/lib/http-server.ts

@@ -1,604 +0,0 @@
-import './polyfill.js'
-import * as sock from 'sock'
-import { HeadersImpl, RequestImpl, ResponseImpl, _readStream } from './http-common.js'
-import { AbortController } from './abort.js'
-import { FdEvent } from '../constants'
-
-type SockHandle = import('sock').SockHandle
-
-// ── Public API ──
-
-export type ServerHandler = (req: Request) => Promise<Response>
-
-// ── Internal types ──
-
-interface NetEvent { lNetworkEvents: number; iErrorCode: number[] }
-
-interface ParsedHeader {
-    method: string
-    target: string
-    version: string
-    headers: Record<string, string>
-    chunked: boolean
-    contentLength: number
-}
-
-interface PendingReq {
-    parsed: ParsedHeader
-    bodyStart: number
-}
-
-interface ActiveReq {
-    req: RequestImpl
-}
-
-interface Conn {
-    sock: SockHandle
-    parts: Uint8Array[]
-    /** Cached total length of `parts` — lets the pending-body wait check
-     *  "have we received enough yet" in O(1) instead of re-concatenating
-     *  every received byte on each read event (O(n²) for large bodies). */
-    partsLen: number
-    pending: PendingReq | null
-    current: ActiveReq | null
-    outQueue: Uint8Array | null
-    resumeRead: (() => void) | null
-    closed: boolean
-    closeAfterFlush: boolean
-    keepAlive: boolean
-    owner: HttpServer
-    /** AbortController for the request currently served on this connection,
-     *  aborted when the client disconnects mid-response. */
-    ac: AbortController | null
-}
-
-const STATUS_TEXT: Record<number, string> = {
-    100: 'Continue', 101: 'Switching Protocols',
-    200: 'OK', 201: 'Created', 202: 'Accepted', 204: 'No Content',
-    301: 'Moved Permanently', 302: 'Found', 304: 'Not Modified',
-    400: 'Bad Request', 401: 'Unauthorized', 403: 'Forbidden', 404: 'Not Found',
-    405: 'Method Not Allowed', 408: 'Request Timeout', 413: 'Payload Too Large',
-    500: 'Internal Server Error', 501: 'Not Implemented', 502: 'Bad Gateway', 503: 'Service Unavailable',
-}
-
-// ── Byte helpers ──
-
-function concatU8(parts: Uint8Array[]): Uint8Array {
-    let total = 0
-    for (const p of parts) total += p.length
-    const out = new Uint8Array(total)
-    let off = 0
-    for (const p of parts) { out.set(p, off); off += p.length }
-    return out
-}
-
-function toArrayBuffer(u8: Uint8Array): ArrayBuffer {
-    // 已经是完整 buffer（byteOffset=0、无尾部余量）时零复制返回——发送大
-    // body 的主路径，避免每片 send 前白拷一份。视图场景仍 slice 出独立副本
-    //（FFI 持有的 buffer 生命周期不受 view 约束）。
-    if (u8.byteOffset === 0 && u8.byteLength === u8.buffer.byteLength) return u8.buffer as ArrayBuffer
-    return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength) as ArrayBuffer
-}
-
-function findCrLfCrLf(buf: Uint8Array): number {
-    const n = buf.length - 3
-    for (let i = 0; i < n; i++) {
-        if (buf[i] === 13 && buf[i + 1] === 10 && buf[i + 2] === 13 && buf[i + 3] === 10) return i
-    }
-    return -1
-}
-
-/** Flatten a `HeadersInit` into `[name, value]` pairs, preserving the
- *  casing the caller provided (Node `addTrailers` semantics). */
-function headersInitToPairs(init: HeadersInit): [string, string][] {
-    if (init instanceof HeadersImpl) {
-        const out: [string, string][] = []
-        for (const [name, value] of init) out.push([name, value])
-        return out
-    }
-    if (Array.isArray(init)) return init.map(([name, value]) => [name, String(value)])
-    const out: [string, string][] = []
-    for (const name of Object.keys(init)) out.push([name, String((init as Record<string, string>)[name])])
-    return out
-}
-
-/** Decode a chunked-transfer body starting at `start`. Returns the decoded
- *  data and the offset just past the terminating CRLF, or null if the buffer
- *  does not yet contain the complete chunked body. */
-function decodeChunked(buf: Uint8Array, start: number): { data: Uint8Array; end: number } | null {
-    let pos = start
-    const parts: Uint8Array[] = []
-    const decoder = new TextDecoder('utf-8')
-    while (pos < buf.length) {
-        let eol = pos
-        while (eol < buf.length && buf[eol] !== 13) eol++
-        if (eol >= buf.length || eol + 1 >= buf.length || buf[eol + 1] !== 10) return null
-        const sizeLine = decoder.decode(buf.subarray(pos, eol)).trim()
-        const semi = sizeLine.indexOf(';')
-        const hex = (semi >= 0 ? sizeLine.slice(0, semi) : sizeLine).trim()
-        const size = parseInt(hex, 16)
-        if (isNaN(size) || size < 0) return null
-        pos = eol + 2
-        if (size === 0) {
-            while (true) {
-                if (pos >= buf.length) return null
-                if (buf[pos] === 13) {
-                    if (pos + 1 >= buf.length || buf[pos + 1] !== 10) return null
-                    pos += 2
-                    return { data: concatU8(parts), end: pos }
-                }
-                let t = pos
-                while (t < buf.length && buf[t] !== 13) t++
-                if (t >= buf.length || t + 1 >= buf.length || buf[t + 1] !== 10) return null
-                pos = t + 2
-            }
-        }
-        if (pos + size > buf.length) return null
-        parts.push(buf.subarray(pos, pos + size))
-        pos += size
-        if (pos + 1 >= buf.length || buf[pos] !== 13 || buf[pos + 1] !== 10) return null
-        pos += 2
-    }
-    return null
-}
-
-// ── Parsing ──
-
-function parseHeader(headerStr: string): ParsedHeader | null {
-    const lines = headerStr.split('\r\n')
-    const first = lines[0]
-    if (!first) return null
-    const sp1 = first.indexOf(' ')
-    const sp2 = first.lastIndexOf(' ')
-    if (sp1 <= 0 || sp2 <= sp1) return null
-    const method = first.slice(0, sp1)
-    const target = first.slice(sp1 + 1, sp2)
-    const version = first.slice(sp2 + 1).trim()
-
-    const headers: Record<string, string> = {}
-    for (let i = 1; i < lines.length; i++) {
-        const line = lines[i]
-        if (!line) continue
-        const ci = line.indexOf(':')
-        if (ci <= 0) continue
-        const name = line.slice(0, ci).trim().toLowerCase()
-        const value = line.slice(ci + 1).trim()
-        if (headers[name] !== undefined) headers[name] = headers[name] + ', ' + value
-        else headers[name] = value
-    }
-
-    const te = (headers['transfer-encoding'] || '').toLowerCase()
-    const chunked = te.indexOf('chunked') >= 0
-    const contentLength = parseInt(headers['content-length'] || '0', 10) || 0
-    return { method, target, version, headers, chunked, contentLength }
-}
-
-// ── Server ──
-
-export class HttpServer {
-    readonly handler: ServerHandler
-    private serverSock: SockHandle | null = null
-    readonly conns = new Map<SockHandle, Conn>()
-    private closed = false
-
-    constructor(handler: ServerHandler) {
-        this.handler = handler
-    }
-
-    /** Actual bound address, or null if not listening. */
-    address(): { addr: string; port: number } | null {
-        if (this.serverSock === null) return null
-        return sock.getsockname(this.serverSock)
-    }
-
-    /** Bind and start listening. Returns 0 on success, -1 on failure. */
-    listen(port: number, host?: string, backlog?: number): number {
-        if (this.serverSock !== null) return -1
-        const s = sock.socket()
-        if (s < 0) return -1
-        if (sock.bind(s, host ?? null, port) !== 0) { sock.closesocket(s); return -1 }
-        if (sock.listen(s, backlog ?? 64) !== 0) { sock.closesocket(s); return -1 }
-        this.serverSock = s
-        sock.set_on_event(s, (event: NetEvent) => {
-            if (event.lNetworkEvents & FdEvent.FD_ACCEPT) this.acceptLoop()
-        })
-        return 0
-    }
-
-    close(): void {
-        if (this.closed) return
-        this.closed = true
-        for (const c of Array.from(this.conns.values())) closeConn(c)
-        this.conns.clear()
-        if (this.serverSock !== null) { sock.closesocket(this.serverSock); this.serverSock = null }
-    }
-
-    private acceptLoop(): void {
-        if (this.closed || this.serverSock === null) return
-        while (true) {
-            const ac = sock.accept(this.serverSock)
-            if (!ac) break
-            const c: Conn = {
-                sock: ac.handle,
-                parts: [],
-                partsLen: 0,
-                pending: null,
-                current: null,
-                outQueue: null,
-                resumeRead: null,
-                closed: false,
-                closeAfterFlush: false,
-                keepAlive: true,
-                owner: this,
-                ac: null,
-            }
-            this.conns.set(c.sock, c)
-            sock.set_on_event(c.sock, (event: NetEvent) => this.onConnEvent(c, event))
-        }
-    }
-
-    private onConnEvent(c: Conn, event: NetEvent): void {
-        if (c.closed) return
-        if (event.lNetworkEvents & FdEvent.FD_READ) onRead(c)
-        if (event.lNetworkEvents & FdEvent.FD_WRITE) flushQueue(c)
-        if (event.lNetworkEvents & FdEvent.FD_CLOSE) {
-            onRead(c)
-            abortConn(c)
-            closeConn(c)
-        }
-    }
-}
-
-export function createServer(handler: ServerHandler): HttpServer {
-    return new HttpServer(handler)
-}
-
-// ── Connection I/O ──
-
-function onRead(c: Conn): void {
-    if (c.closed) return
-    while (true) {
-        const d = sock.recv(c.sock, 8192)
-        if (!d) break
-        const u8 = new Uint8Array(d)
-        c.parts.push(u8)
-        c.partsLen += u8.length
-    }
-    if (!c.closed) tryProcess(c)
-}
-
-/** Send `data`, or queue it when the kernel send buffer is full.
- *  Returns true when the data was fully handed to the kernel, or false
- *  when it has been buffered (or partially handed over) and the caller
- *  should back off until `flushQueue` drains and calls `c.resumeRead`. */
-function queueSend(c: Conn, data: Uint8Array): boolean {
-    if (c.closed || data.length === 0) return true
-    if (c.outQueue && c.outQueue.length > 0) {
-        c.outQueue = concatU8([c.outQueue, data])
-        return false
-    }
-    const ret = sock.send(c.sock, toArrayBuffer(data))
-    if (ret < 0) {
-        abortConn(c)
-        closeConn(c)
-        return true
-    }
-    if (ret < data.length) {
-        c.outQueue = data.subarray(ret)
-        return false
-    }
-    return true
-}
-
-function flushQueue(c: Conn): void {
-    if (c.closed) return
-    if (!c.outQueue || c.outQueue.length === 0) {
-        if (c.closeAfterFlush) closeConn(c)
-        else resumeReader(c)
-        return
-    }
-    const q = c.outQueue
-    const ret = sock.send(c.sock, toArrayBuffer(q))
-    if (ret < 0) {
-        abortConn(c)
-        closeConn(c)
-        return
-    }
-    if (ret < q.length) {
-        c.outQueue = q.subarray(ret)
-        return
-    }
-    c.outQueue = null
-    if (c.closeAfterFlush) closeConn(c)
-    else resumeReader(c)
-}
-
-function closeConn(c: Conn): void {
-    if (c.closed) return
-    c.closed = true
-    resumeReader(c)
-    if (c.sock >= 0) sock.closesocket(c.sock)
-    c.owner.conns.delete(c.sock)
-}
-
-/** Abort the in-flight request (notifying its handler via `req.signal`).
- *  Safe to call when idle or already aborted: the controller is cleared so
- *  a fresh request on this connection gets a fresh signal. */
-function abortConn(c: Conn): void {
-    const ac = c.ac
-    c.ac = null
-    if (ac) ac.abort()
-}
-
-/** Resolve the pending back-pressure awaiter, if any. Called whenever the
- *  send queue drains or the connection closes. */
-function resumeReader(c: Conn): void {
-    const r = c.resumeRead
-    c.resumeRead = null
-    if (r) r()
-}
-
-/** Close the connection once a response is fully flushed, when the
- *  handler or client asked for `Connection: close`. */
-function finishResponse(c: Conn): void {
-    if (c.closeAfterFlush && !c.outQueue) closeConn(c)
-}
-
-/** Frame `data` as a single chunked-transfer block: `<hex size>\r\n<data>\r\n`. */
-function encodeChunkFrame(data: Uint8Array, enc: TextEncoder): Uint8Array {
-    return concatU8([enc.encode(data.byteLength.toString(16) + '\r\n'), data, enc.encode('\r\n')])
-}
-
-/** Read `body` one chunk at a time and send it out. When the kernel send
- *  buffer fills up (`queueSend` returns false) we pause on `c.resumeRead`,
- *  which `flushQueue` resumes once the socket drains — backpressure. */
-async function writeStreamingBody(c: Conn, body: ReadableStream<Uint8Array> | null, chunked: boolean, trailer: Promise<HeadersInit> | undefined): Promise<void> {
-    if (c.closed || body == null) return
-    const reader = body.getReader()
-    const enc = new TextEncoder()
-    try {
-        while (!c.closed) {
-            const { done, value } = await reader.read()
-            if (done) break
-            if (value && value.byteLength > 0) {
-                // 切成 ≤64KB 再入 queueSend：单发 200MB 级大 chunk 时
-                // toArrayBuffer 会全量 slice 复制，partial drain 又每次复制
-                // 剩余（O(n²)），XP 32 位 1GB 上直接把进程水位顶穿导致断连；
-                // 小片让每次复制/发送恒为常数大小，backpressure 语义不变。
-                const MAX_SEND = 65536
-                for (let off = 0; off < value.byteLength; off += MAX_SEND) {
-                    const piece = value.byteLength <= MAX_SEND ? value : value.subarray(off, Math.min(off + MAX_SEND, value.byteLength))
-                    const frame = chunked ? encodeChunkFrame(piece, enc) : piece
-                    if (!queueSend(c, frame)) {
-                        await new Promise<void>((resolve) => { c.resumeRead = resolve })
-                    }
-                    if (c.closed) break
-                }
-            }
-        }
-        if (c.closed) {
-            // 客户端断开（FD_CLOSE / send 失败）：取消响应体，让 producer 感知
-            //（execd 借此 kill 子进程），而不是干等它自然结束。
-            try { await reader.cancel() } catch (e) {
-                console.error('[http-server] body cancel error:', e)
-            }
-            return
-        }
-        if (chunked) {
-            let terminator = '0\r\n\r\n'
-            if (trailer) {
-                try {
-                    const pairs = headersInitToPairs(await trailer)
-                    if (pairs.length > 0) {
-                        let s = '0\r\n'
-                        for (const [name, value] of pairs) s += name + ': ' + value + '\r\n'
-                        s += '\r\n'
-                        terminator = s
-                    }
-                } catch (e) {
-                    console.error('[http-server] trailers promise rejected:', e)
-                }
-            }
-            queueSend(c, enc.encode(terminator))
-        }
-        finishResponse(c)
-    } finally {
-        reader.releaseLock()
-    }
-}
-
-// ── Request state machine ──
-
-function whole(c: Conn): Uint8Array {
-    return concatU8(c.parts)
-}
-
-function trimParts(c: Conn, buf: Uint8Array, consumed: number): void {
-    if (consumed >= buf.length) {
-        c.parts = []
-        c.partsLen = 0
-    } else {
-        c.parts = [buf.subarray(consumed)]
-        c.partsLen = buf.length - consumed
-    }
-}
-
-function tryProcess(c: Conn): void {
-    if (c.closed || c.current) return
-
-    if (c.pending) {
-        const bodyStart = c.pending.bodyStart
-        const parsed = c.pending.parsed
-        if (!parsed.chunked) {
-            // O(1) length check while the body is still arriving — only
-            // concatenate once, when the last byte is in.
-            const end = bodyStart + parsed.contentLength
-            if (end > c.partsLen) return
-            const buf = whole(c)
-            c.pending = null
-            dispatchRequest(c, parsed, buf.subarray(bodyStart, end), end, buf)
-            return
-        }
-        // chunked: no total length up front, so a decode attempt still needs
-        // the concatenated view (re-tried per read event as before).
-        const buf = whole(c)
-        const dec = decodeChunked(buf, bodyStart)
-        if (!dec) return
-        c.pending = null
-        dispatchRequest(c, parsed, dec.data, dec.end, buf)
-        return
-    }
-
-    // Header phase: bodies are checked against `partsLen` above, so a full
-    // concatenation is only needed here — once per request, not per read.
-    const buf = whole(c)
-    const headerEnd = findCrLfCrLf(buf)
-    if (headerEnd < 0) return
-    const absEnd = headerEnd + 4
-    const headerStr = new TextDecoder('utf-8').decode(buf.subarray(0, absEnd))
-    const parsed = parseHeader(headerStr)
-    if (!parsed) { closeConn(c); return }
-
-    const bodyStart = absEnd
-    if (parsed.chunked) {
-        const dec = decodeChunked(buf, bodyStart)
-        if (!dec) {
-            c.pending = { parsed, bodyStart }
-            return
-        }
-        dispatchRequest(c, parsed, dec.data, dec.end, buf)
-    } else if (parsed.contentLength > 0) {
-        if (bodyStart + parsed.contentLength > buf.length) {
-            c.pending = { parsed, bodyStart }
-            return
-        }
-        dispatchRequest(c, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength, buf)
-    } else {
-        dispatchRequest(c, parsed, new Uint8Array(0), bodyStart, buf)
-    }
-}
-
-function dispatchRequest(c: Conn, parsed: ParsedHeader, body: Uint8Array, end: number, wholeBuf?: Uint8Array): void {
-    const connHeader = (parsed.headers['connection'] || '').toLowerCase()
-    if (parsed.version === 'HTTP/1.1') c.keepAlive = connHeader.indexOf('close') < 0
-    else c.keepAlive = connHeader.indexOf('keep-alive') >= 0
-
-    let host = parsed.headers['host']
-    if (!host) {
-        const a = c.owner.address()
-        const addrStr = a ? (a.addr.includes(':') ? `[${a.addr}]` : a.addr) : 'localhost'
-        host = a ? addrStr + ':' + a.port : 'localhost'
-    }
-
-    const isAbsolute = parsed.target.startsWith('http://') || parsed.target.startsWith('https://')
-    const url = isAbsolute ? parsed.target : 'http://' + host + parsed.target
-
-    const ac = new AbortController()
-    const req = new RequestImpl(url, {
-        method: parsed.method,
-        headers: new HeadersImpl(parsed.headers),
-        body: body.length > 0 ? body : undefined,
-        signal: ac.signal,
-    })
-
-    c.ac = ac
-    c.current = { req }
-    // `wholeBuf` is the concatenation the caller already produced — reuse it
-    // instead of concatenating the very same parts a second time.
-    trimParts(c, wholeBuf ?? whole(c), end)
-    void handleRequest(c)
-}
-
-async function handleRequest(c: Conn): Promise<void> {
-    const req = c.current?.req
-    if (!req) { c.current = null; return }
-
-    let res: Response
-    try {
-        const result = await c.owner.handler(req)
-        if (result instanceof ResponseImpl) {
-            res = result
-        } else {
-            console.error('[http-server] handler must return a Response')
-            res = new ResponseImpl('Internal Server Error', { status: 500 })
-        }
-    } catch (e) {
-        console.error('[http-server] handler error:', e)
-        res = new ResponseImpl('Internal Server Error', { status: 500 })
-    }
-
-    if (c.closed) return
-    try {
-        await sendResponse(c, req.method, res)
-    } catch (e) {
-        console.error('[http-server] response send error:', e)
-        if (!c.closed) closeConn(c)
-        return
-    }
-    if (c.closed) return
-
-    c.current = null
-    if (!c.closeAfterFlush) tryProcess(c)
-}
-
-function buildHead(status: number, statusText: string, headers: HeadersImpl): Uint8Array {
-    let head = 'HTTP/1.1 ' + status + ' ' + statusText + '\r\n'
-    for (const [name, value] of headers) head += name + ': ' + value + '\r\n'
-    head += '\r\n'
-    return new TextEncoder().encode(head)
-}
-
-async function sendResponse(c: Conn, method: string, res: Response): Promise<void> {
-    const status = res.status
-    const statusText = res.statusText || STATUS_TEXT[status] || 'OK'
-    const headers = new HeadersImpl(res.headers)
-
-    const headOnly = method === 'HEAD'
-    const bodyless = (status >= 100 && status < 200) || status === 204 || status === 304
-
-    if (!headers.has('connection')) headers.set('Connection', c.keepAlive ? 'keep-alive' : 'close')
-    const connHdr = (headers.get('connection') || '').toLowerCase()
-    if (!c.keepAlive || connHdr === 'close') c.closeAfterFlush = true
-
-    if (bodyless) {
-        headers.delete('Transfer-Encoding')
-        headers.delete('Content-Length')
-        headers.delete('Trailer')
-        queueSend(c, buildHead(status, statusText, headers))
-        finishResponse(c)
-        return
-    }
-
-    if (headOnly) {
-        headers.delete('Transfer-Encoding')
-        headers.delete('Trailer')
-        if (!headers.has('content-length')) {
-            try {
-                const full = await _readStream(res.body)
-                headers.set('Content-Length', String(full.length))
-            } catch { /* leave length unspecified */ }
-        }
-        if (c.closed) return
-        queueSend(c, buildHead(status, statusText, headers))
-        finishResponse(c)
-        return
-    }
-
-    // Body is streamed out chunk by chunk. A declared Content-Length sends
-    // the bytes as-is; otherwise we use chunked framing.
-    const chunked = (headers.get('transfer-encoding') || '').toLowerCase() === 'chunked' ||
-        !headers.has('content-length')
-    // Trailing headers are only emitted when the body is chunk-framed and a
-    // `Trailer` declaration header is present (Node addTrailers semantics).
-    const trailerDeclared = (headers.get('trailer') || '').trim().length > 0
-    if (chunked) {
-        headers.delete('Content-Length')
-        if (!headers.has('transfer-encoding')) headers.set('Transfer-Encoding', 'chunked')
-        if (!trailerDeclared) headers.delete('Trailer')
-    } else {
-        headers.delete('Transfer-Encoding')
-        headers.delete('Trailer')
-    }
-    queueSend(c, buildHead(status, statusText, headers))
-    await writeStreamingBody(c, res.body, chunked, (chunked && trailerDeclared) ? res.trailers : undefined)
-}