@bytecodealliance/preview2-shim 0.14.2 → 0.15.0

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

@@ -1,131 +1,285 @@
-// See: https://github.com/nodejs/node/blob/main/src/tcp_wrap.cc
-const {
-  TCP,
-  constants: TCPConstants,
-  TCPConnectWrap,
-} = process.binding("tcp_wrap");
-const { ShutdownWrap } = process.binding("stream_wrap");
+import {
+  createFuture,
+  createReadableStream,
+  createReadableStreamPollState,
+  createWritableStream,
+  futureDispose,
+  futureTakeValue,
+  pollStateReady,
+  verifyPollsDroppedForDrop,
+} from "./worker-thread.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 { Socket, Server } from "node:net";
 
-/** @type {Map<number, NodeJS.Socket>} */
-export const openedSockets = new Map();
-
-let socketCnt = 0;
+/**
+ * @typedef {import("../../types/interfaces/wasi-sockets-network.js").IpSocketAddress} IpSocketAddress
+ * @typedef {import("../../../types/interfaces/wasi-sockets-tcp.js").IpAddressFamily} IpAddressFamily
+ * @typedef {import("node:net").Socket} TcpSocket
+ *
+ * @typedef {{
+ *   tcpSocket: number,
+ *   err: Error | null,
+ *   pollState: PollState,
+ * }} PendingAccept
+ *
+ * @typedef {{
+ *   state: number,
+ *   future: number | null,
+ *   socket: TcpSocket | null,
+ *   listenBacklogSize: number,
+ *   handle: TCP,
+ *   pendingAccepts: PendingAccept[],
+ *   pollState: PollState,
+ * }} TcpSocketRecord
+ */
 
-export function getSocketOrThrow(socketId) {
-  const socket = openedSockets.get(socketId);
-  if (!socket) throw "invalid-socket";
-  return socket;
-}
+/**
+ * @type {Map<number, TcpSocketRecord>}
+ */
+export const tcpSockets = new Map();
 
-//-----------------------------------------------------
+let tcpSocketCnt = 0;
 
 /**
  * @param {IpAddressFamily} addressFamily
- * @returns {NodeJS.Socket}
  */
 export function createTcpSocket() {
-  const socket = new TCP(TCPConstants.SOCKET | TCPConstants.SERVER);
-  openedSockets.set(++socketCnt, socket);
-  return Promise.resolve(socketCnt);
+  const handle = new TCP(TCPConstants.SOCKET);
+  tcpSockets.set(++tcpSocketCnt, {
+    state: SOCKET_STATE_INIT,
+    future: null,
+    listenBacklogSize: 128,
+    handle,
+    pendingAccepts: [],
+    pollState: { ready: true, listener: null, polls: [], parentStream: null },
+  });
+  return tcpSocketCnt;
 }
 
-export function socketTcpBind(id, payload) {
-  const { localAddress, localPort, family, isIpV6Only } = payload;
-  const socket = getSocketOrThrow(id);
-
-  let bind = "bind"; // ipv4
-  if (family.toLocaleLowerCase() === "ipv6") {
-    bind = "bind6"; // ipv6
-  }
-
-  let flags = 0;
-  if (isIpV6Only) {
-    flags |= TCPConstants.UV_TCP_IPV6ONLY;
+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;
   }
-
-  return socket[bind](localAddress, localPort, flags);
 }
 
-export function socketTcpConnect(id, payload) {
-  const socket = getSocketOrThrow(id);
-  const { remoteAddress, remotePort, localAddress, localPort, family } =
-    payload;
+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
+  );
+}
 
-  return new Promise((resolve) => {
-    const _onClientConnectComplete = (err) => {
-      if (err) resolve(err);
-      resolve(0);
-    };
-    const connectReq = new TCPConnectWrap();
-    connectReq.oncomplete = _onClientConnectComplete;
-    connectReq.address = remoteAddress;
-    connectReq.port = remotePort;
-    connectReq.localAddress = localAddress;
-    connectReq.localPort = localPort;
-    let connect = "connect"; // ipv4
-    if (family.toLocaleLowerCase() === "ipv6") {
-      connect = "connect6";
-    }
+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
+  );
+}
 
-    socket.onread = (_buffer) => {
-      // TODO: handle data received from the server
-    };
-    socket.readStart();
+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 err = socket[connect](connectReq, remoteAddress, remotePort);
-    resolve(err);
+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,
+    listenBacklogSize: 128,
+    handle: accept.tcpSocket._handle,
+    pendingAccepts: [],
+    pollState: accept.pollState,
   });
+  return [
+    tcpSocketCnt,
+    createReadableStream(accept.tcpSocket, accept.pollState),
+    createWritableStream(accept.tcpSocket),
+  ];
 }
 
-export function socketTcpListen(id, payload) {
-  const socket = getSocketOrThrow(id);
-  const { backlogSize } = payload;
-  return socket.listen(backlogSize);
+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 socket = getSocketOrThrow(id);
+  const { handle } = tcpSockets.get(id);
   const out = {};
-  socket.getsockname(out);
-  return 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 socket = getSocketOrThrow(id);
+  const { handle } = tcpSockets.get(id);
   const out = {};
-  socket.getpeername(out);
-  return 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, payload) {
-  const socket = getSocketOrThrow(id);
-
-  // eslint-disable-next-line no-unused-vars
-  const { shutdownType } = payload;
-
-  return new Promise((resolve) => {
-    const req = new ShutdownWrap();
-    req.oncomplete = () => {
-      resolve(0);
-    };
-    req.handle = socket;
-    req.callback = () => {
-      resolve(0);
-    };
-    const err = socket.shutdown(req);
-    resolve(err);
-  });
+export function socketTcpShutdown(id, shutdownType) {
+  const socket = tcpSockets.get(id);
+  if (socket.state !== SOCKET_STATE_CONNECTION) throw "invalid-state";
+  // Node.js only supports a write shutdown, which is triggered on end
+  if (shutdownType === "send" || shutdownType === "both")
+    socket.tcpSocket.end();
 }
 
-export function socketTcpSetKeepAlive(id, payload) {
-  const socket = getSocketOrThrow(id);
-  const { enable } = payload;
-
-  return socket.setKeepAlive(enable);
+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);
 }
 
 export function socketTcpDispose(id) {
-  const socket = getSocketOrThrow(id);
-  socket.close();
-  return 0;
+  const socket = tcpSockets.get(id);
+  verifyPollsDroppedForDrop(socket.pollState, "tcp socket");
+  socket.handle.close();
+  tcpSockets.delete(id);
 }