@bytecodealliance/preview2-shim 0.18.1 → 0.20.0

package/dist/io/worker-socket-tcp.js

@@ -0,0 +1,251 @@
+import { createFuture, createReadableStream, createReadableStreamPollState, createWritableStream, futureDispose, futureTakeValue, pollStateReady, verifyPollsDroppedForDrop, } from "./worker-thread.js";
+import process from "node:process";
+// TODO: tcp_wrap is no longer exposed in newer versions of Node.js
+const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
+import { convertSocketError, convertSocketErrorCode, ipSocketAddress, isIPv4MappedAddress, isMulticastIpAddress, isUnicastIpAddress, isWildcardAddress, noLookup, serializeIpAddress, SOCKET_STATE_BIND, SOCKET_STATE_BOUND, SOCKET_STATE_CLOSED, SOCKET_STATE_CONNECT, SOCKET_STATE_CONNECTION, SOCKET_STATE_INIT, SOCKET_STATE_LISTEN, SOCKET_STATE_LISTENER, } from "./worker-sockets.js";
+import { Server, Socket as TcpSocket } from "node:net";
+const win = process.platform === "win32";
+export const tcpSockets = new Map();
+let tcpSocketCnt = 0;
+export function createTcpSocket() {
+    const handle = new TCP(TCPConstants.SOCKET);
+    tcpSockets.set(++tcpSocketCnt, {
+        state: SOCKET_STATE_INIT,
+        future: null,
+        tcpSocket: null,
+        listenBacklogSize: 128,
+        handle,
+        pendingAccepts: [],
+        pollState: {
+            ready: true,
+            listener: null,
+            polls: [],
+            parentStream: null,
+        },
+    });
+    return tcpSocketCnt;
+}
+export function socketTcpFinish(id, fromState, toState) {
+    const socket = tcpSockets.get(id);
+    if (socket.state !== fromState) {
+        throw "not-in-progress";
+    }
+    if (!socket.pollState?.ready) {
+        throw "would-block";
+    }
+    const { tag, val } = futureTakeValue(socket.future)?.val ?? {};
+    futureDispose(socket.future, false);
+    socket.future = null;
+    if (tag === "err") {
+        socket.state = SOCKET_STATE_CLOSED;
+        throw val;
+    }
+    else {
+        socket.state = toState;
+        // for the listener, we must immediately transition back to unresolved
+        if (toState === SOCKET_STATE_LISTENER) {
+            socket.pollState.ready = false;
+        }
+        return val;
+    }
+}
+export function socketTcpBindStart(id, localAddress, family) {
+    const socket = tcpSockets.get(id);
+    if (socket.state !== SOCKET_STATE_INIT) {
+        throw "invalid-state";
+    }
+    if (family !== localAddress.tag ||
+        !isUnicastIpAddress(localAddress) ||
+        isIPv4MappedAddress(localAddress)) {
+        throw "invalid-argument";
+    }
+    socket.state = SOCKET_STATE_BIND;
+    const { handle } = socket;
+    socket.future = createFuture((async () => {
+        const address = serializeIpAddress(localAddress);
+        const port = localAddress.val.port;
+        const code = localAddress.tag === "ipv6"
+            ? handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY)
+            : handle.bind(address, port);
+        if (code !== 0) {
+            throw convertSocketErrorCode(-code);
+        }
+        // This is a Node.js / libuv quirk to force the bind error to be thrown
+        // (specifically address-in-use).
+        {
+            const out = {};
+            const code = handle.getsockname(out);
+            if (code !== 0) {
+                throw convertSocketErrorCode(-code);
+            }
+        }
+    })(), socket.pollState);
+}
+export function socketTcpConnectStart(id, remoteAddress, family) {
+    const socket = tcpSockets.get(id);
+    if (socket.state !== SOCKET_STATE_INIT && socket.state !== SOCKET_STATE_BOUND) {
+        throw "invalid-state";
+    }
+    if (isWildcardAddress(remoteAddress) ||
+        family !== remoteAddress.tag ||
+        !isUnicastIpAddress(remoteAddress) ||
+        isMulticastIpAddress(remoteAddress) ||
+        remoteAddress.val.port === 0 ||
+        isIPv4MappedAddress(remoteAddress)) {
+        throw "invalid-argument";
+    }
+    socket.state = SOCKET_STATE_CONNECT;
+    socket.future = createFuture(new Promise((resolve, reject) => {
+        const tcpSocket = (socket.tcpSocket = new TcpSocket({
+            // @ts-expect-error Not present in type definition
+            handle: socket.handle,
+            pauseOnCreate: true,
+            allowHalfOpen: true,
+        }));
+        function handleErr(err) {
+            tcpSocket.off("connect", handleConnect);
+            reject(convertSocketError(err));
+        }
+        function handleConnect() {
+            tcpSocket.off("error", handleErr);
+            resolve([createReadableStream(tcpSocket), createWritableStream(tcpSocket)]);
+        }
+        tcpSocket.once("connect", handleConnect);
+        tcpSocket.once("error", handleErr);
+        tcpSocket.connect({
+            port: remoteAddress.val.port,
+            host: serializeIpAddress(remoteAddress) ?? undefined,
+            lookup: noLookup,
+        });
+    }), socket.pollState);
+}
+export function socketTcpListenStart(id) {
+    const socket = tcpSockets.get(id);
+    if (socket.state !== SOCKET_STATE_BOUND) {
+        throw "invalid-state";
+    }
+    const { handle } = socket;
+    socket.state = SOCKET_STATE_LISTEN;
+    socket.future = createFuture(new Promise((resolve, reject) => {
+        const server = new Server({
+            pauseOnConnect: true,
+            allowHalfOpen: true,
+        });
+        function handleErr(err) {
+            server.off("listening", handleListen);
+            reject(convertSocketError(err));
+        }
+        function handleListen() {
+            server.off("error", handleErr);
+            server.on("connection", (tcpSocket) => {
+                pollStateReady(socket.pollState);
+                const pollState = createReadableStreamPollState(tcpSocket);
+                socket.pendingAccepts.push({
+                    tcpSocket,
+                    err: null,
+                    pollState,
+                });
+            });
+            server.on("error", (err) => {
+                pollStateReady(socket.pollState);
+                socket.pendingAccepts.push({
+                    tcpSocket: null,
+                    err,
+                    pollState: null,
+                });
+            });
+            resolve();
+        }
+        server.once("listening", handleListen);
+        server.once("error", handleErr);
+        server.listen(handle, socket.listenBacklogSize);
+    }), socket.pollState);
+}
+export function socketTcpAccept(id) {
+    const socket = tcpSockets.get(id);
+    if (socket.state !== SOCKET_STATE_LISTENER) {
+        throw "invalid-state";
+    }
+    if (socket.pendingAccepts.length === 0) {
+        throw "would-block";
+    }
+    const accept = socket.pendingAccepts.shift();
+    if (!accept || accept.err) {
+        socket.state = SOCKET_STATE_CLOSED;
+        throw convertSocketError(accept?.err);
+    }
+    if (socket.pollState && socket.pendingAccepts.length === 0) {
+        socket.pollState.ready = false;
+    }
+    tcpSockets.set(++tcpSocketCnt, {
+        state: SOCKET_STATE_CONNECTION,
+        future: null,
+        tcpSocket: accept.tcpSocket,
+        listenBacklogSize: 128,
+        // @ts-expect-error
+        handle: accept.tcpSocket?._handle,
+        pendingAccepts: [],
+        pollState: accept.pollState,
+    });
+    return [
+        tcpSocketCnt,
+        // @ts-expect-error
+        createReadableStream(accept.tcpSocket, accept.pollState ?? undefined),
+        createWritableStream(accept.tcpSocket),
+    ];
+}
+export function socketTcpSetListenBacklogSize(id, backlogSize) {
+    const socket = tcpSockets.get(id);
+    if (socket.state === SOCKET_STATE_LISTEN || socket.state === SOCKET_STATE_LISTENER) {
+        throw "not-supported";
+    }
+    if (socket.state !== SOCKET_STATE_INIT &&
+        socket.state !== SOCKET_STATE_BIND &&
+        socket.state !== SOCKET_STATE_BOUND) {
+        throw "invalid-state";
+    }
+    socket.listenBacklogSize = Number(backlogSize);
+}
+export function socketTcpGetLocalAddress(id) {
+    const { handle } = tcpSockets.get(id);
+    const out = {};
+    const code = handle.getsockname(out);
+    if (code !== 0) {
+        throw convertSocketErrorCode(-code);
+    }
+    return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+}
+export function socketTcpGetRemoteAddress(id) {
+    const { handle } = tcpSockets.get(id);
+    const out = {};
+    const code = handle.getpeername(out);
+    if (code !== 0) {
+        throw convertSocketErrorCode(-code);
+    }
+    return ipSocketAddress(out.family.toLowerCase(), out.address, out.port);
+}
+export function socketTcpShutdown(id, _shutdownType) {
+    const socket = tcpSockets.get(id);
+    if (socket.state !== SOCKET_STATE_CONNECTION) {
+        throw "invalid-state";
+    }
+    if (win && socket.tcpSocket?.destroySoon) {
+        socket.tcpSocket.destroySoon();
+    }
+    else {
+        socket.tcpSocket?.destroy();
+    }
+}
+export function socketTcpSetKeepAlive(id, { keepAlive, keepAliveIdleTime }) {
+    const { handle } = tcpSockets.get(id);
+    const code = handle.setKeepAlive(keepAlive, Number(keepAliveIdleTime / 1000000000n));
+    if (code !== 0) {
+        throw convertSocketErrorCode(-code);
+    }
+}
+export function socketTcpDispose(id) {
+    const socket = tcpSockets.get(id);
+    verifyPollsDroppedForDrop(socket.pollState, "tcp socket");
+    socket.handle.close();
+    tcpSockets.delete(id);
+}

package/dist/io/worker-socket-udp.d.ts

@@ -0,0 +1,54 @@
+import { Socket } from "node:dgram";
+import { PollState } from "./worker-thread.js";
+import { IpAddressFamily, IpSocketAddress } from "../../types/interfaces/wasi-sockets-network.js";
+import { OutgoingDatagram } from "../../types/interfaces/wasi-sockets-udp.js";
+interface UdpSocketRecord {
+    state: number;
+    remoteAddress: string | null;
+    remotePort: number | null;
+    sendBufferSize: number | null;
+    receiveBufferSize: number | null;
+    unicastHopLimit: number;
+    udpSocket: Socket;
+    future: number | null;
+    serializedLocalAddress: string | null;
+    pollState: PollState;
+    incomingDatagramStream: DatagramStreamRecord | null;
+    outgoingDatagramStream: DatagramStreamRecord | null;
+}
+interface DatagramStreamRecord {
+    id: number;
+    active: boolean;
+    error: any | null;
+    socket: UdpSocketRecord;
+    pollState: PollState;
+    queue?: Buffer[];
+    cleanup: (() => void) | null;
+}
+export declare const udpSockets: Map<number, UdpSocketRecord>;
+export declare const datagramStreams: Map<number, DatagramStreamRecord>;
+export declare function createUdpSocket({ family, unicastHopLimit, }: {
+    family: IpAddressFamily;
+    unicastHopLimit: number;
+}): number;
+export declare function socketUdpBindStart(id: number, localAddress: any, family: any): void;
+export declare function socketUdpBindFinish(id: number): any;
+export declare function socketUdpGetLocalAddress(id: number): IpSocketAddress;
+/**
+ * @param {number} id
+ * @returns {IpSocketAddress}
+ */
+export declare function socketUdpGetRemoteAddress(id: any): IpSocketAddress;
+export declare function socketUdpStream(id: any, remoteAddress: any): number[] | Promise<unknown>;
+export declare function socketUdpSetReceiveBufferSize(id: number, bufferSize: bigint): void;
+export declare function socketUdpSetSendBufferSize(id: number, bufferSize: bigint): void;
+export declare function socketUdpSetUnicastHopLimit(id: number, hopLimit: number): void;
+export declare function socketUdpGetReceiveBufferSize(id: number): Promise<bigint>;
+export declare function socketUdpGetSendBufferSize(id: number): Promise<bigint>;
+export declare function socketUdpGetUnicastHopLimit(id: number): number;
+export declare function socketUdpDispose(id: number): Promise<unknown>;
+export declare function socketIncomingDatagramStreamReceive(id: number, maxResults: bigint): Buffer<ArrayBufferLike>[] | undefined;
+export declare function socketOutgoingDatagramStreamSend(id: number, datagrams: OutgoingDatagram[]): Promise<bigint>;
+export declare function socketOutgoingDatagramStreamCheckSend(id: number): bigint;
+export declare function socketDatagramStreamDispose(id: any): void;
+export {};