@bytecodealliance/preview2-shim 0.17.7 → 0.17.9

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

@@ -1,37 +1,37 @@
 import {
-    createFuture,
-    createReadableStream,
-    createReadableStreamPollState,
-    createWritableStream,
-    futureDispose,
-    futureTakeValue,
-    pollStateReady,
-    verifyPollsDroppedForDrop,
-} from './worker-thread.js';
-import process from 'node:process';
-const { TCP, constants: TCPConstants } = process.binding('tcp_wrap');
+  createFuture,
+  createReadableStream,
+  createReadableStreamPollState,
+  createWritableStream,
+  futureDispose,
+  futureTakeValue,
+  pollStateReady,
+  verifyPollsDroppedForDrop,
+} from "./worker-thread.js";
+import process from "node:process";
+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 { Socket, Server } from 'node:net';
+  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 { Socket, Server } from "node:net";
 
-const win = process.platform === 'win32';
+const win = process.platform === "win32";
 
 /**
  * @typedef {import("../../types/interfaces/wasi-sockets-network.js").IpSocketAddress} IpSocketAddress
@@ -66,278 +66,266 @@ let tcpSocketCnt = 0;
  * @param {IpAddressFamily} addressFamily
  */
 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;
+  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;
+  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
-    );
+  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 Socket({
-                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),
-                lookup: noLookup,
-            });
-        }),
-        socket.pollState
-    );
+  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 Socket({
+        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),
+        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
-    );
+  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.err) {
-        socket.state = SOCKET_STATE_CLOSED;
-        throw convertSocketError(accept.err);
-    }
-    if (socket.pendingAccepts.length === 0) {
-        socket.pollState.ready = false;
-    }
-    tcpSockets.set(++tcpSocketCnt, {
-        state: SOCKET_STATE_CONNECTION,
-        future: null,
-        tcpSocket: accept.tcpSocket,
-        listenBacklogSize: 128,
-        handle: accept.tcpSocket._handle,
-        pendingAccepts: [],
-        pollState: accept.pollState,
-    });
-    return [
-        tcpSocketCnt,
-        createReadableStream(accept.tcpSocket, accept.pollState),
-        createWritableStream(accept.tcpSocket),
-    ];
+  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.err) {
+    socket.state = SOCKET_STATE_CLOSED;
+    throw convertSocketError(accept.err);
+  }
+  if (socket.pendingAccepts.length === 0) {
+    socket.pollState.ready = false;
+  }
+  tcpSockets.set(++tcpSocketCnt, {
+    state: SOCKET_STATE_CONNECTION,
+    future: null,
+    tcpSocket: accept.tcpSocket,
+    listenBacklogSize: 128,
+    handle: accept.tcpSocket._handle,
+    pendingAccepts: [],
+    pollState: accept.pollState,
+  });
+  return [
+    tcpSocketCnt,
+    createReadableStream(accept.tcpSocket, accept.pollState),
+    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);
+  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);
+  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);
+  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();
-    }
+  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 / 1_000_000_000n)
-    );
-    if (code !== 0) {
-        throw convertSocketErrorCode(-code);
-    }
+  const { handle } = tcpSockets.get(id);
+  const code = handle.setKeepAlive(keepAlive, Number(keepAliveIdleTime / 1_000_000_000n));
+  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);
+  const socket = tcpSockets.get(id);
+  verifyPollsDroppedForDrop(socket.pollState, "tcp socket");
+  socket.handle.close();
+  tcpSockets.delete(id);
 }