@bytecodealliance/preview2-shim 0.14.0 → 0.14.2

package/lib/nodejs/sockets/wasi-sockets.js

@@ -16,8 +16,8 @@ import {
 } from "../../io/calls.js";
 import { ioCall, pollableCreate } from "../../io/worker-io.js";
 import { deserializeIpAddress } from "./socket-common.js";
-import { TcpSocketImpl } from "./tcp-socket-impl.js";
-import { IncomingDatagramStream, OutgoingDatagramStream, UdpSocketImpl } from "./udp-socket-impl.js";
+import { TcpSocket, tcpSocketImplCreate } from "./tcp-socket-impl.js";
+import { IncomingDatagramStream, OutgoingDatagramStream, UdpSocket, udpSocketImplCreate } from "./udp-socket-impl.js";
 
 const symbolDispose = Symbol.dispose || Symbol.for("dispose");
 
@@ -120,11 +120,14 @@ export const IpAddressFamily = {
 };
 
 export class WasiSockets {
+  #allowDnsLookup = true;
+  #allowTcp = true;
+  #allowUdp = true;
   networkCnt = 1;
   socketCnt = 1;
 
   // TODO: figure out what the max number of sockets should be
-  maxSockets = 100;
+  MAX_SOCKET_INSTANCES = 100;
 
   /** @type {Network} */ networkInstance = null;
   /** @type {Map<number,Network>} */ networks = new Map();
@@ -141,32 +144,12 @@ export class WasiSockets {
       }
     }
 
-    class UdpSocket extends UdpSocketImpl {
-      /**
-       * @param {IpAddressFamily} addressFamily
-       * */
-      constructor(addressFamily) {
-        super(addressFamily, net.socketCnt++);
-        net.udpSockets.set(this.id, this);
-      }
-    }
-
     this.udp = {
       UdpSocket,
       OutgoingDatagramStream,
       IncomingDatagramStream,
     };
 
-    class TcpSocket extends TcpSocketImpl {
-      /**
-       * @param {IpAddressFamily} addressFamily
-       * */
-      constructor(addressFamily) {
-        super(addressFamily, TcpSocket, net.socketCnt++);
-        net.tcpSockets.set(this.id, this);
-      }
-    }
-
     this.tcp = {
       TcpSocket,
     };
@@ -199,14 +182,23 @@ export class WasiSockets {
         );
 
         assert(
-          net.socketCnt + 1 > net.maxSockets,
+          net.socketCnt + 1 > net.MAX_SOCKET_INSTANCES,
           errorCode.newSocketLimit,
           "The new socket resource could not be created because of a system limit"
         );
 
         try {
-          return new UdpSocket(addressFamily);
+          const id = net.socketCnt++;
+          const udpSocket = udpSocketImplCreate(addressFamily, id);
+          udpSocket.allowed = () => {
+            return net.#allowUdp;
+          };
+          net.udpSockets.set(id, udpSocket);
+          return udpSocket;
         } catch (err) {
+          console.log("udp socket create error", {
+            err,
+          });
           assert(true, errorCode.notSupported, err);
         }
       },
@@ -227,17 +219,25 @@ export class WasiSockets {
         );
 
         assert(
-          net.socketCnt + 1 > net.maxSockets,
+          net.socketCnt + 1 > net.MAX_SOCKET_INSTANCES,
           errorCode.newSocketLimit,
           "The new socket resource could not be created because of a system limit"
         );
 
-        // try {
-          return new TcpSocket(addressFamily);
-        // } catch (err) {
-        //   // assert(true, errorCode.unknown, err);
-        //   throw err;
-        // }
+        try {
+          const id = net.socketCnt++;
+          const tcpSocket = tcpSocketImplCreate(addressFamily, id);
+          tcpSocket.allowed = () => {
+            return net.#allowTcp;
+          };
+          net.tcpSockets.set(id, tcpSocket);
+          return tcpSocket;
+        } catch (err) {
+          console.log("tcp socket create error", {
+            err,
+          });
+          assert(true, errorCode.notSupported, err);
+        }
       },
     };
 
@@ -255,7 +255,7 @@ export class WasiSockets {
             const family = `ipv${isIP(address)}`;
             return {
               tag: family,
-              val: deserializeIpAddress(address),
+              val: deserializeIpAddress(address, family),
             };
           });
         }
@@ -305,13 +305,34 @@ export class WasiSockets {
        * @throws {invalid-argument} `name` is a syntactically invalid domain name or IP address.
        */
       resolveAddresses(network, name) {
+        if (!net.#allowDnsLookup)
+          throw 'permanent-resolver-failure';
         // TODO: bind to network
         return resolveAddressStreamCreate(name);
       },
     };
   }
+
+  static _denyDnsLookup (sockets) {
+    sockets.#allowDnsLookup = false;
+  }
+  static _denyTcp (sockets) {
+    sockets.#allowTcp = false;
+  }
+  static _denyUdp (sockets) {
+    sockets.#allowUdp = false;
+  }
 }
 
+export const denyDnsLookup = WasiSockets._denyDnsLookup;
+delete WasiSockets._denyDnsLookup;
+
+export const denyTcp = WasiSockets._denyTcp;
+delete WasiSockets._denyTcp;
+
+export const denyUdp = WasiSockets._denyUdp;
+delete WasiSockets._denyUdp;
+
 function convertResolveAddressError(err) {
   switch (err.code) {
     default:

package/lib/nodejs/sockets.js

@@ -1,11 +1,25 @@
-import { WasiSockets } from "./sockets/wasi-sockets.js";
-
-export const { 
-    ipNameLookup,
-    instanceNetwork, 
-    network, 
-    tcpCreateSocket,
-    udpCreateSocket,
-    tcp,
-    udp,
-} = new WasiSockets();
+import { WasiSockets, denyDnsLookup, denyTcp, denyUdp } from "./sockets/wasi-sockets.js";
+
+export function _denyDnsLookup() {
+  denyDnsLookup(sockets);
+}
+
+export function _denyTcp() {
+  denyTcp(sockets);
+}
+
+export function _denyUdp() {
+  denyUdp(sockets);
+}
+
+const sockets = new WasiSockets();
+
+export const {
+  ipNameLookup,
+  instanceNetwork,
+  network,
+  tcpCreateSocket,
+  udpCreateSocket,
+  tcp,
+  udp,
+} = sockets;

package/lib/synckit/index.js

@@ -33,7 +33,6 @@ import {
 } from "node:worker_threads";
 
 const DEFAULT_WORKER_BUFFER_SIZE = 1024;
-const syncFnCache = new Map();
 
 function extractProperties(object) {
   if (object && typeof object === "object") {
@@ -45,61 +44,45 @@ function extractProperties(object) {
   }
 }
 
-export function createSyncFn(workerPath, bufferSizeOrOptions, timeout) {
+const CALL_TIMEOUT = undefined;
+
+export function createSyncFn(workerPath, callbackHandler) {
   if (!path.isAbsolute(workerPath)) {
     throw new Error("`workerPath` must be absolute");
   }
-  const cachedSyncFn = syncFnCache.get(workerPath);
-  if (cachedSyncFn) {
-    return cachedSyncFn;
-  }
-  const syncFn = startWorkerThread(
-    workerPath,
-    typeof bufferSizeOrOptions === "number"
-      ? { bufferSize: bufferSizeOrOptions, timeout }
-      : bufferSizeOrOptions
-  );
-  syncFnCache.set(workerPath, syncFn);
-  return syncFn;
-}
-
-function startWorkerThread(
-  workerPath,
-  {
-    bufferSize = DEFAULT_WORKER_BUFFER_SIZE,
-    timeout = undefined,
-    execArgv = [],
-  } = {}
-) {
   const { port1: mainPort, port2: workerPort } = new MessageChannel();
   const worker = new Worker(workerPath, {
     workerData: { workerPort },
     transferList: [workerPort],
-    execArgv: execArgv
+    execArgv: []
+  });
+  worker.on('message', ({ type, id, payload }) => {
+    if (!type)
+      throw new Error('Internal error: Expected a type of a worker callback');
+    callbackHandler(type, id, payload);
   });
   let nextID = 0;
   const syncFn = (...args) => {
-    const id = nextID++;
-    const sharedBuffer = new SharedArrayBuffer(bufferSize);
+    const cid = nextID++;
+    const sharedBuffer = new SharedArrayBuffer(DEFAULT_WORKER_BUFFER_SIZE);
     const sharedBufferView = new Int32Array(sharedBuffer);
-    const msg = { sharedBuffer, id, args };
+    const msg = { sharedBuffer, cid, args };
     worker.postMessage(msg);
-    const status = Atomics.wait(sharedBufferView, 0, 0, timeout);
+    const status = Atomics.wait(sharedBufferView, 0, 0, CALL_TIMEOUT);
     if (!["ok", "not-equal"].includes(status)) {
       throw new Error("Internal error: Atomics.wait() failed: " + status);
     }
     const {
-      id: id2,
+      cid: cid2,
       result,
       error,
       properties,
     } = receiveMessageOnPort(mainPort).message;
-    if (id !== id2) {
-      throw new Error(`Internal error: Expected id ${id} but got id ${id2}`);
+    if (cid !== cid2) {
+      throw new Error(`Internal error: Expected id ${cid} but got id ${cid2}`);
     }
     if (error) {
-      if (error instanceof Error)
-        throw Object.assign(error, properties);
+      if (error instanceof Error) throw Object.assign(error, properties);
       throw error;
     }
     return result;
@@ -114,14 +97,14 @@ export function runAsWorker(fn) {
   }
   const { workerPort } = workerData;
   try {
-    parentPort.on("message", ({ sharedBuffer, id, args }) => {
+    parentPort.on("message", ({ sharedBuffer, cid, args }) => {
       (async () => {
         const sharedBufferView = new Int32Array(sharedBuffer);
         let msg;
         try {
-          msg = { id, result: await fn(...args) };
+          msg = { cid, result: await fn(...args) };
         } catch (error) {
-          msg = { id, error, properties: extractProperties(error) };
+          msg = { cid, error, properties: extractProperties(error) };
         }
         workerPort.postMessage(msg);
         Atomics.add(sharedBufferView, 0, 1);
@@ -129,10 +112,10 @@ export function runAsWorker(fn) {
       })();
     });
   } catch (error) {
-    parentPort.on("message", ({ sharedBuffer, id }) => {
+    parentPort.on("message", ({ sharedBuffer, cid }) => {
       const sharedBufferView = new Int32Array(sharedBuffer);
       workerPort.postMessage({
-        id,
+        cid,
         error,
         properties: extractProperties(error),
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytecodealliance/preview2-shim",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "WASI Preview2 shim for JS environments",
   "author": "Guy Bedford, Eduardo Rodrigues<16357187+eduardomourar@users.noreply.github.com>",
   "type": "module",

package/types/interfaces/wasi-http-types.d.ts

@@ -37,7 +37,14 @@ export namespace WasiHttpTypes {
    * syntactically invalid, or if a header was forbidden.
    */
   /**
-   * Get all of the values corresponding to a key.
+   * Get all of the values corresponding to a key. If the key is not present
+   * in this `fields`, an empty list is returned. However, if the key is
+   * present but empty, this is represented by a list with one or more
+   * empty field-values present.
+   */
+  /**
+   * Returns `true` when the key is present in this `fields`. If the key is
+   * syntactically invalid, `false` is returned.
    */
   /**
    * Set all of the values for a key. Clears any existing values for that
@@ -255,10 +262,14 @@ export namespace WasiHttpTypes {
    * The outer `option` represents future readiness. Users can wait on this
    * `option` to become `some` using the `subscribe` method.
    * 
-   * The `result` represents that either the HTTP Request or Response body,
-   * as well as any trailers, were received successfully, or that an error
-   * occured receiving them. The optional `trailers` indicates whether or not
-   * trailers were present in the body.
+   * The outer `result` is used to retrieve the trailers or error at most
+   * once. It will be success on the first call in which the outer option
+   * is `some`, and error on subsequent calls.
+   * 
+   * The inner `result` represents that either the HTTP Request or Response
+   * body, as well as any trailers, were received successfully, or that an
+   * error occured receiving them. The optional `trailers` indicates whether
+   * or not trailers were present in the body.
    * 
    * When some `trailers` are returned by this method, the `trailers`
    * resource is immutable, and a child. Use of the `set`, `append`, or
@@ -349,7 +360,7 @@ import type { InputStream } from '../interfaces/wasi-io-streams.js';
 export { InputStream };
 import type { OutputStream } from '../interfaces/wasi-io-streams.js';
 export { OutputStream };
-import type { IoError } from '../interfaces/wasi-io-error.js';
+import type { Error as IoError } from '../interfaces/wasi-io-error.js';
 export { IoError };
 import type { Pollable } from '../interfaces/wasi-io-poll.js';
 export { Pollable };
@@ -618,15 +629,16 @@ export type Trailers = Fields;
 export type StatusCode = number;
 export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };
 
-export class FutureIncomingResponse {
-  subscribe(): Pollable;
-  get(): Result<Result<IncomingResponse, ErrorCode>, void> | undefined;
+export class OutgoingBody {
+  write(): OutputStream;
+  static finish(this_: OutgoingBody, trailers: Trailers | undefined): void;
 }
 
 export class Fields {
   constructor()
   static fromList(entries: [FieldKey, FieldValue][]): Fields;
   get(name: FieldKey): FieldValue[];
+  has(name: FieldKey): boolean;
   set(name: FieldKey, value: FieldValue[]): void;
   delete(name: FieldKey): void;
   append(name: FieldKey, value: FieldValue): void;
@@ -634,33 +646,18 @@ export class Fields {
   clone(): Fields;
 }
 
-export class FutureTrailers {
+export class FutureIncomingResponse {
   subscribe(): Pollable;
-  get(): Result<Trailers | undefined, ErrorCode> | undefined;
+  get(): Result<Result<IncomingResponse, ErrorCode>, void> | undefined;
 }
 
-export class OutgoingRequest {
-  constructor(headers: Headers)
-  body(): OutgoingBody;
+export class IncomingRequest {
   method(): Method;
-  setMethod(method: Method): void;
   pathWithQuery(): string | undefined;
-  setPathWithQuery(pathWithQuery: string | undefined): void;
   scheme(): Scheme | undefined;
-  setScheme(scheme: Scheme | undefined): void;
   authority(): string | undefined;
-  setAuthority(authority: string | undefined): void;
   headers(): Headers;
-}
-
-export class RequestOptions {
-  constructor()
-  connectTimeoutMs(): Duration | undefined;
-  setConnectTimeoutMs(ms: Duration | undefined): void;
-  firstByteTimeoutMs(): Duration | undefined;
-  setFirstByteTimeoutMs(ms: Duration | undefined): void;
-  betweenBytesTimeoutMs(): Duration | undefined;
-  setBetweenBytesTimeoutMs(ms: Duration | undefined): void;
+  consume(): IncomingBody;
 }
 
 export class IncomingBody {
@@ -668,15 +665,13 @@ export class IncomingBody {
   static finish(this_: IncomingBody): FutureTrailers;
 }
 
-export class ResponseOutparam {
-  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
+export class FutureTrailers {
+  subscribe(): Pollable;
+  get(): Result<Result<Trailers | undefined, ErrorCode>, void> | undefined;
 }
 
-export class IncomingRequest {
-  method(): Method;
-  pathWithQuery(): string | undefined;
-  scheme(): Scheme | undefined;
-  authority(): string | undefined;
+export class IncomingResponse {
+  status(): StatusCode;
   headers(): Headers;
   consume(): IncomingBody;
 }
@@ -689,13 +684,30 @@ export class OutgoingResponse {
   body(): OutgoingBody;
 }
 
-export class IncomingResponse {
-  status(): StatusCode;
+export class OutgoingRequest {
+  constructor(headers: Headers)
+  body(): OutgoingBody;
+  method(): Method;
+  setMethod(method: Method): void;
+  pathWithQuery(): string | undefined;
+  setPathWithQuery(pathWithQuery: string | undefined): void;
+  scheme(): Scheme | undefined;
+  setScheme(scheme: Scheme | undefined): void;
+  authority(): string | undefined;
+  setAuthority(authority: string | undefined): void;
   headers(): Headers;
-  consume(): IncomingBody;
 }
 
-export class OutgoingBody {
-  write(): OutputStream;
-  static finish(this_: OutgoingBody, trailers: Trailers | undefined): void;
+export class RequestOptions {
+  constructor()
+  connectTimeout(): Duration | undefined;
+  setConnectTimeout(duration: Duration | undefined): void;
+  firstByteTimeout(): Duration | undefined;
+  setFirstByteTimeout(duration: Duration | undefined): void;
+  betweenBytesTimeout(): Duration | undefined;
+  setBetweenBytesTimeout(duration: Duration | undefined): void;
+}
+
+export class ResponseOutparam {
+  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
 }

package/types/interfaces/wasi-sockets-tcp.d.ts

@@ -24,6 +24,11 @@ export namespace WasiSocketsTcp {
    * - `not-in-progress`:           A `bind` operation is not in progress.
    * - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
    * 
+   * # Implementors note
+   * When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT
+   * state of a recently closed socket on the same local address (i.e. the SO_REUSEADDR socket
+   * option should be set implicitly on platforms that require it).
+   * 
    * # References
    * - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
    * - <https://man7.org/linux/man-pages/man2/bind.2.html>