@bytecodealliance/preview3-shim 0.1.2 → 0.2.1

package/lib/nodejs/workers/tcp-worker.js

@@ -1,370 +0,0 @@
-import { Socket, Server } from "node:net";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
-import { once } from "node:events";
-
-import { Router } from "../workers/resource-worker.js";
-import { serializeIpAddress, makeIpAddress, ipAddressConflict } from "../sockets/address.js";
-import { SocketError } from "../sockets/error.js";
-
-import process from "node:process";
-const { TCP, constants: TCPConstants } = process.binding("tcp_wrap");
-
-// Socket instances stored by ID
-const sockets = new Map();
-// Unique IDs for sockets
-let NEXT_SOCKET_ID = 0n;
-
-// Handle worker messages
-Router()
-  .beforeAll((msg) => {
-    if (msg.op !== "tcp-create" && !sockets.has(msg.socketId)) {
-      throw new Error("Invalid socket ID");
-    }
-  })
-  .op("tcp-create", handleTcpCreate)
-  .op("tcp-bind", handleTcpBind)
-  .op("tcp-connect", handleTcpConnect)
-  .op("tcp-listen", handleTcpListen)
-  .op("tcp-send", handleTcpSend)
-  .op("tcp-receive", handleTcpReceive)
-  .op("tcp-get-local-address", handleGetLocalAddress)
-  .op("tcp-get-remote-address", handleGetRemoteAddress)
-  .op("tcp-set-listen-backlog-size", handleTcpSetBacklogSize)
-  .op("tcp-set-keep-alive", handleTcpSetKeepAlive)
-  .op("tcp-recv-buffer-size", handleRecvBufferSize)
-  .op("tcp-send-buffer-size", handleSendBufferSize)
-  .op("tcp-dispose", handleTcpDispose);
-
-// Create a new TCP socket
-function handleTcpCreate({ family }) {
-  const socketId = NEXT_SOCKET_ID++;
-  const handle = new TCP(TCPConstants.SOCKET);
-
-  sockets.set(socketId, {
-    handle,
-    family,
-    tcp: null,
-    server: null,
-    backlog: 128,
-    localAddress: null,
-    disposed: false,
-    activeStreams: 0,
-  });
-
-  return { socketId };
-}
-
-// Bind a socket to local address
-async function handleTcpBind({ socketId, localAddress }) {
-  const socket = sockets.get(socketId);
-  const address = serializeIpAddress(localAddress);
-  const port = localAddress.val.port;
-
-  const { handle, family } = socket;
-
-  const hasConflict = [...sockets].some(
-    ([id, { localAddress: boundAddress }]) =>
-      id !== socketId && boundAddress && ipAddressConflict(boundAddress, localAddress),
-  );
-
-  if (hasConflict) {
-    const err = new Error("EADDRINUSE");
-    err.code = "EADDRINUSE";
-    throw err;
-  }
-
-  await new Promise((resolve, reject) => {
-    let code;
-    if (family === "ipv6") {
-      code = handle.bind6(address, port, TCPConstants.UV_TCP_IPV6ONLY);
-    } else {
-      code = handle.bind(address, port);
-    }
-
-    if (code !== 0) {
-      reject(SocketError.from(-code));
-    } else {
-      resolve();
-    }
-  });
-
-  const out = {};
-  const code = handle.getsockname(out);
-  if (code !== 0) {
-    throw SocketError.from(-code);
-  }
-  socket.localAddress = makeIpAddress(out.family.toLowerCase(), out.address, out.port);
-}
-
-// Connect a socket to remote address
-async function handleTcpConnect({ socketId, remoteAddress }) {
-  const socket = sockets.get(socketId);
-  const host = serializeIpAddress(remoteAddress);
-  const port = remoteAddress.val.port;
-
-  const tcp = (socket.tcp = new Socket({
-    handle: socket.handle,
-    pauseOnCreate: true,
-    allowHalfOpen: true,
-  }));
-
-  const onConnect = once(tcp, "connect");
-  const onError = once(tcp, "error").then(([err]) => {
-    throw err;
-  });
-
-  // TODO(tandr): Add lookup
-  tcp.connect({ port, host });
-
-  await Promise.race([onConnect, onError]);
-}
-
-async function handleTcpListen({ socketId, stream }) {
-  const writer = stream.getWriter();
-  const socket = sockets.get(socketId);
-  const { handle, backlog, family } = socket;
-
-  const server = new Server({
-    pauseOnConnect: true,
-    allowHalfOpen: true,
-  });
-
-  const onListening = once(server, "listening");
-  const onError = once(server, "error").then(([err]) => {
-    throw err;
-  });
-
-  server.listen(handle, backlog);
-
-  await Promise.race([onListening, onError]);
-
-  const addr = server.address();
-  if (addr && typeof addr === "object") {
-    socket.localAddress = makeIpAddress(family, addr.address, addr.port);
-  }
-
-  server.on("connection", (conn) => {
-    conn.allowHalfOpen = true;
-    const id = NEXT_SOCKET_ID++;
-    sockets.set(id, {
-      handle: conn._handle,
-      family,
-      backlog,
-      tcp: conn,
-      server: null,
-      localAddress: makeIpAddress(family, conn.localAddress, conn.localPort),
-      disposed: false,
-      activeStreams: 0,
-    });
-    writer.write({ family, socketId: id });
-  });
-
-  socket.server = server;
-  server.on("error", (err) => stream.abort(err));
-  server.on("close", () => writer.close());
-}
-
-async function handleTcpSend({ socketId, stream }) {
-  const socket = sockets.get(socketId);
-  socket.activeStreams++;
-
-  const { tcp } = socket;
-  const readable = Readable.fromWeb(stream);
-
-  try {
-    await pipeline(readable, tcp);
-  } finally {
-    socket.activeStreams--;
-    cleanupDisposedSocket(socketId, socket);
-  }
-}
-
-async function handleTcpReceive({ socketId, stream }) {
-  const socket = sockets.get(socketId);
-  const writer = stream.getWriter();
-  socket.activeStreams++;
-
-  const { tcp } = socket;
-
-  try {
-    await new Promise((resolve, reject) => {
-      let settled = false;
-      let pending = Promise.resolve();
-
-      const cleanup = () => {
-        tcp.off("data", onData);
-        tcp.off("end", onEnd);
-        tcp.off("error", onError);
-      };
-      const settle = (err) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      };
-      const onData = (chunk) => {
-        tcp.pause();
-        pending = pending.then(async () => {
-          try {
-            await writer.write(chunk);
-          } catch {
-            settle();
-            return;
-          } finally {
-            // Always undo the pause, even if the guest dropped or cancelled the
-            // receive stream. Otherwise the send path can remain backpressured
-            // forever.
-            tcp.resume();
-          }
-        }, settle);
-      };
-      const onEnd = () => {
-        pending = pending.then(async () => {
-          try {
-            await writer.close();
-          } catch {
-            // The guest can drop the receive stream before remote EOF.
-          }
-          settle();
-        }, settle);
-      };
-      const onError = (err) => {
-        pending = pending.finally(() => settle(err));
-      };
-
-      writer.closed.then(
-        () => settle(),
-        () => settle(),
-      );
-      tcp.on("data", onData);
-      tcp.once("end", onEnd);
-      tcp.once("error", onError);
-      tcp.resume();
-    });
-  } finally {
-    writer.releaseLock();
-    socket.activeStreams--;
-    cleanupDisposedSocket(socketId, socket);
-  }
-}
-
-function cleanupDisposedSocket(socketId, socket) {
-  if (!socket.disposed || socket.activeStreams > 0) {
-    return;
-  }
-
-  if (socket.server) {
-    socket.server.close();
-  }
-
-  if (socket.tcp) {
-    socket.tcp.destroy();
-  }
-  if (socket.handle) {
-    socket.handle.close();
-  }
-
-  sockets.delete(socketId);
-}
-
-async function handleGetLocalAddress({ socketId }) {
-  const socket = sockets.get(socketId);
-  const out = {};
-
-  const code = socket.handle.getsockname(out);
-  if (code !== 0) {
-    throw new SocketError.from(-code);
-  }
-
-  return makeIpAddress(out.family.toLowerCase(), out.address, out.port);
-}
-
-async function handleGetRemoteAddress({ socketId }) {
-  const socket = sockets.get(socketId);
-  const out = {};
-
-  const code = socket.handle.getpeername(out);
-  if (code !== 0) {
-    throw new SocketError.from(-code);
-  }
-
-  return makeIpAddress(out.family.toLowerCase(), out.address, out.port);
-}
-
-function handleTcpSetBacklogSize({ socketId, value }) {
-  const socket = sockets.get(socketId);
-  socket.backlog = Number(value);
-}
-
-async function handleTcpSetKeepAlive({ socketId, keepAliveEnabled, keepAliveIdleTime }) {
-  const socket = sockets.get(socketId);
-  const time = Number(keepAliveIdleTime / 1_000_000_000n);
-
-  const code = socket.handle.setKeepAlive(keepAliveEnabled, time);
-  if (code !== 0) {
-    throw mapErrorCode(-code);
-  }
-}
-
-async function handleRecvBufferSize({ socketId }) {
-  const socket = sockets.get(socketId);
-
-  if (socket.tcp) {
-    return BigInt(socket.tcp.getRecvBufferSize());
-  } else {
-    return await getDefaultReceiveBufferSize();
-  }
-}
-
-async function handleSendBufferSize({ socketId }) {
-  const socket = sockets.get(socketId);
-  if (socket.tcp) {
-    return BigInt(socket.tcp.getSendBufferSize());
-  } else {
-    return await getDefaultSendBufferSize();
-  }
-}
-
-function handleTcpDispose({ socketId }) {
-  const socket = sockets.get(socketId);
-  if (!socket) {
-    return;
-  }
-
-  socket.disposed = true;
-  cleanupDisposedSocket(socketId, socket);
-}
-
-let _recvBufferSize, _sendBufferSize;
-async function getDefaultBufferSizes() {
-  var s = new Socket();
-  s.bind(0);
-  await new Promise((resolve, reject) => {
-    s.once("error", reject);
-    s.once("listening", resolve);
-  });
-  _recvBufferSize = BigInt(s.getRecvBufferSize());
-  _sendBufferSize = BigInt(s.getSendBufferSize());
-  s.close();
-}
-
-export async function getDefaultSendBufferSize() {
-  if (!_sendBufferSize) {
-    await getDefaultBufferSizes();
-  }
-  return _sendBufferSize;
-}
-
-export async function getDefaultReceiveBufferSize() {
-  if (!_recvBufferSize) {
-    await getDefaultBufferSizes();
-  }
-  return _recvBufferSize;
-}

package/lib/nodejs/workers/udp-worker.js

@@ -1,194 +0,0 @@
-import { once } from "node:events";
-
-import { Router } from "../workers/resource-worker.js";
-import {
-  serializeIpAddress,
-  makeIpAddress,
-  ipAddressConflict,
-  isLoopbackIpAddress,
-} from "../sockets/address.js";
-
-import dgram from "node:dgram";
-
-const sockets = new Map();
-// Unique IDs for sockets
-let NEXT_SOCKET_ID = 0n;
-
-export function noLookup(ip, _opts, cb) {
-  cb(null, ip);
-}
-
-Router()
-  .beforeAll((msg) => {
-    if (msg.op !== "udp-create" && !sockets.has(msg.socketId)) {
-      throw new Error("Invalid socket ID");
-    }
-  })
-  .op("udp-create", handleCreate)
-  .op("udp-bind", handleBind)
-  .op("udp-connect", handleConnect)
-  .op("udp-disconnect", handleDisconnect)
-  .op("udp-send", handleSend)
-  .op("udp-receive", handleReceive)
-  .op("udp-get-local-address", handleGetLocal)
-  .op("udp-set-unicast-hop-limit", handleSetHop)
-  .op("udp-recv-buffer-size", handleRecvBuffer)
-  .op("udp-send-buffer-size", handleSendBuffer)
-  .op("udp-dispose", handleDispose);
-
-function handleCreate({ family }) {
-  const socketId = NEXT_SOCKET_ID++;
-  const socket = {
-    family,
-    connected: null,
-    localAddress: null,
-    receiveQueue: [],
-  };
-  socket.udp = createSocket(socket);
-  sockets.set(socketId, socket);
-
-  return { socketId };
-}
-
-function createSocket(socket) {
-  const type = socket.family === "ipv6" ? "udp6" : "udp4";
-  const ipv6Only = socket.family === "ipv6";
-  const udp = dgram.createSocket({
-    type,
-    ipv6Only,
-    reuseAddr: false,
-    lookup: noLookup,
-  });
-
-  udp.on("message", (msg, rinfo) => socket.receiveQueue.push({ msg, rinfo }));
-  udp.on("error", () => {});
-  return udp;
-}
-
-async function handleBind({ socketId, localAddress }) {
-  const socket = sockets.get(socketId);
-  const hasConflict = [...sockets].some(
-    ([id, { localAddress: boundAddress }]) =>
-      id !== socketId && boundAddress && ipAddressConflict(boundAddress, localAddress),
-  );
-
-  if (hasConflict) {
-    const err = new Error("EADDRINUSE");
-    err.code = "EADDRINUSE";
-    throw err;
-  }
-
-  const addr = serializeIpAddress(localAddress);
-  const port = localAddress.val.port;
-
-  const onListening = once(socket.udp, "listening");
-  const onError = once(socket.udp, "error").then(([err]) => {
-    throw err;
-  });
-
-  socket.udp.bind(port, addr);
-
-  await Promise.race([onListening, onError]);
-  const boundAddr = socket.udp.address();
-  socket.localAddress = makeIpAddress(socket.family, boundAddr.address, boundAddr.port);
-}
-
-async function handleConnect({ socketId, remoteAddress }) {
-  const socket = sockets.get(socketId);
-  const preserveLocalAddress =
-    socket.connected &&
-    socket.localAddress &&
-    isLoopbackIpAddress(socket.connected) &&
-    isLoopbackIpAddress(remoteAddress);
-
-  if (socket.connected) {
-    const localAddress = preserveLocalAddress ? socket.localAddress : null;
-    await new Promise((resolve) => socket.udp.close(resolve));
-    socket.udp = createSocket(socket);
-    if (localAddress) {
-      await handleBind({ socketId, localAddress });
-    } else {
-      socket.localAddress = null;
-    }
-  }
-
-  const addr = serializeIpAddress(remoteAddress);
-  const port = remoteAddress.val.port;
-
-  await new Promise((resolve, reject) => {
-    socket.udp.connect(port, addr, (err) => (err ? reject(err) : resolve()));
-  });
-  const boundAddr = socket.udp.address();
-  socket.localAddress = makeIpAddress(socket.family, boundAddr.address, boundAddr.port);
-  socket.connected = remoteAddress;
-}
-
-function handleDisconnect({ socketId }) {
-  const socket = sockets.get(socketId);
-  socket.udp.disconnect();
-  socket.connected = null;
-}
-
-async function handleSend({ socketId, data, remoteAddress }) {
-  const socket = sockets.get(socketId);
-  const isConnected = socket.connected != null;
-
-  await new Promise((resolve, reject) => {
-    if (isConnected) {
-      socket.udp.send(data, (err) => (err ? reject(err) : resolve()));
-    } else {
-      const addr = serializeIpAddress(remoteAddress);
-      const port = remoteAddress.val.port;
-
-      socket.udp.send(data, port, addr, (err) => (err ? reject(err) : resolve()));
-    }
-  });
-
-  const boundAddr = socket.udp.address();
-  socket.localAddress = makeIpAddress(socket.family, boundAddr.address, boundAddr.port);
-}
-
-async function handleReceive({ socketId }) {
-  const socket = sockets.get(socketId);
-  if (socket.receiveQueue.length === 0) {
-    await Promise.race([
-      once(socket.udp, "message"),
-      once(socket.udp, "error").then(([err]) => {
-        throw err;
-      }),
-    ]);
-  }
-
-  const { msg, rinfo } = socket.receiveQueue.shift();
-  return {
-    data: msg,
-    remoteAddress: makeIpAddress(socket.family, rinfo.address, rinfo.port),
-  };
-}
-
-function handleGetLocal({ socketId }) {
-  const socket = sockets.get(socketId);
-  const addr = socket.udp.address();
-  return makeIpAddress(socket.family, addr.address, addr.port);
-}
-
-function handleSetHop({ socketId, value }) {
-  const socket = sockets.get(socketId);
-  socket.udp.setTTL(value);
-}
-
-function handleRecvBuffer({ socketId }) {
-  const socket = sockets.get(socketId);
-  return BigInt(socket.udp.getRecvBufferSize());
-}
-
-function handleSendBuffer({ socketId }) {
-  const socket = sockets.get(socketId);
-  return BigInt(socket.udp.getSendBufferSize());
-}
-
-function handleDispose({ socketId }) {
-  const socket = sockets.get(socketId);
-  socket.udp.close();
-  sockets.delete(socketId);
-}