@bytecodealliance/preview2-shim 0.14.1 → 0.15.0

package/README.md

@@ -2,9 +2,9 @@
 
 WASI Preview2 implementations for Node.js & browsers.
 
-Browser support is considered experimental, and not currently suitable for production applications.
+Node.js support is fully tested and conformant against the Wasmtime test suite.
 
-Node.js support is currently being stabilized, which can be tracked in https://github.com/bytecodealliance/jco/milestone/1.
+Browser support is considered experimental, and not currently suitable for production applications.
 
 # License
 

package/lib/browser/filesystem.js

@@ -39,12 +39,13 @@ function getChildEntry (parentEntry, subpath, openFlags) {
     if (!entry || !entry.dir) throw 'not-directory';
     segmentIdx = subpath.indexOf('/');
     const segment = segmentIdx === -1 ? subpath : subpath.slice(0, segmentIdx);
-    if (segment === '.' || segment === '') return entry;
     if (segment === '..') throw 'no-entry';
-    if (!entry.dir[segment] && openFlags.create)
+    if (segment === '.' || segment === '');
+    else if (!entry.dir[segment] && openFlags.create)
       entry = entry.dir[segment] = openFlags.directory ? { dir: {} } : { source: new Uint8Array([]) };
     else
       entry = entry.dir[segment];
+    subpath = subpath.slice(segmentIdx + 1);
   } while (segmentIdx !== -1)
   if (!entry) throw 'no-entry';
   return entry;
@@ -179,13 +180,13 @@ class Descriptor {
   stat() {
     let type = 'unknown', size = BigInt(0);
     if (this.#entry.source) {
-      type = 'directory';
-    }
-    else if (this.#entry.dir) {
       type = 'regular-file';
       const source = getSource(this.#entry);
       size = BigInt(source.byteLength);
     }
+    else if (this.#entry.dir) {
+      type = 'directory';
+    }
     return {
       type,
       linkCount: BigInt(0),

package/lib/browser/random.js

@@ -33,7 +33,7 @@ export const random = {
       for (var generated = 0; generated < len; generated += MAX_BYTES) {
         // buffer.slice automatically checks if the end is past the end of
         // the buffer so we don't have to here
-        crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES));
+        crypto.getRandomValues(bytes.subarray(generated, generated + MAX_BYTES));
       }
     } else {
       crypto.getRandomValues(bytes);

package/lib/browser/sockets.js

@@ -64,12 +64,6 @@ export const tcp = {
   },
   addressFamily() {
   
-  },
-  ipv6Only() {
-  
-  },
-  setIpv6Only() {
-  
   },
   setListenBacklogSize() {
   
@@ -152,14 +146,6 @@ export const udp = {
   
   },
   
-  ipv6Only () {
-  
-  },
-  
-  setIpv6Only () {
-  
-  },
-  
   unicastHopLimit () {
   
   },

package/lib/io/calls.js

@@ -1,10 +1,21 @@
 let call_id = 0;
 
-// Call is a 32 bit integer, leading 16 bits are call number, trailing 16 bits allow custom call types
+// Call is a 32 bit integer, leading 8 bits are call number, trailing 24 bits allow custom call types
 export const CALL_MASK = 0xff000000;
 export const CALL_TYPE_MASK = 0x00ffffff;
 export const CALL_SHIFT = 24;
 
+// Type indiciator for generic Stream, Future, and Poll calls
+let cnt = 0;
+export const STDIN = ++cnt;
+export const STDOUT = ++cnt;
+export const STDERR = ++cnt;
+export const FILE = ++cnt;
+export const HTTP = ++cnt;
+export const SOCKET_TCP = ++cnt;
+export const SOCKET_UDP = ++cnt;
+export const CLOCKS = ++cnt;
+
 // Io Input Stream
 export const INPUT_STREAM_CREATE = ++call_id << CALL_SHIFT;
 export const INPUT_STREAM_READ = ++call_id << CALL_SHIFT;
@@ -34,31 +45,84 @@ export const OUTPUT_STREAM_GET_TOTAL_BYTES = ++call_id << CALL_SHIFT;
 // Io Poll
 export const POLL_POLLABLE_READY = ++call_id << CALL_SHIFT;
 export const POLL_POLLABLE_BLOCK = ++call_id << CALL_SHIFT;
+export const POLL_POLLABLE_DISPOSE = ++call_id << CALL_SHIFT;
 export const POLL_POLL_LIST = ++call_id << CALL_SHIFT;
 
 // Futures
-export const FUTURE_GET_VALUE_AND_DISPOSE = ++call_id << CALL_SHIFT;
 export const FUTURE_DISPOSE = ++call_id << CALL_SHIFT;
+export const FUTURE_TAKE_VALUE = ++call_id << CALL_SHIFT;
+export const FUTURE_SUBSCRIBE = ++call_id << CALL_SHIFT;
 
 // Http
 export const HTTP_CREATE_REQUEST = ++call_id << 24;
 export const HTTP_OUTPUT_STREAM_FINISH = ++call_id << CALL_SHIFT;
+// Http server
+export const HTTP_SERVER_START = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_STOP = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_INCOMING_HANDLER = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_SET_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_CLEAR_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
+export const HTTP_OUTGOING_BODY_DISPOSE = ++call_id << CALL_SHIFT;
 
 // Clocks
-export const CLOCKS_NOW = ++call_id << 24;
-export const CLOCKS_DURATION_SUBSCRIBE = ++call_id << 24;
-export const CLOCKS_INSTANT_SUBSCRIBE = ++call_id << 24;
+export const CLOCKS_NOW = ++call_id << CALL_SHIFT;
+export const CLOCKS_DURATION_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const CLOCKS_INSTANT_SUBSCRIBE = ++call_id << CALL_SHIFT;
 
 // Sockets
-export const SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST = ++call_id << 24;
-export const SOCKET_RESOLVE_ADDRESS_GET_AND_DISPOSE_REQUEST = ++call_id << 24;
-export const SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST = ++call_id << 24;
+// Tcp
+export const SOCKET_TCP_CREATE_HANDLE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_BIND_START = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_BIND_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_CONNECT_START = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_CONNECT_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_LISTEN_START = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_LISTEN_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_IS_LISTENING = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_ACCEPT = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_GET_LOCAL_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_GET_REMOTE_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SET_KEEP_ALIVE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SET_LISTEN_BACKLOG_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SHUTDOWN = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_DISPOSE = ++call_id << CALL_SHIFT;
+// Udp
+export const SOCKET_UDP_CREATE_HANDLE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_BIND_START = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_BIND_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_STREAM = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_DISPOSE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_LOCAL_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_REMOTE_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_UNICAST_HOP_LIMIT = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SET_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SET_UNICAST_HOP_LIMIT = ++call_id << CALL_SHIFT;
+export const SOCKET_INCOMING_DATAGRAM_STREAM_RECEIVE = ++call_id << CALL_SHIFT;
+export const SOCKET_OUTGOING_DATAGRAM_STREAM_CHECK_SEND =
+  ++call_id << CALL_SHIFT;
+export const SOCKET_OUTGOING_DATAGRAM_STREAM_SEND = ++call_id << CALL_SHIFT;
+export const SOCKET_DATAGRAM_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const SOCKET_DATAGRAM_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
 
-// Type indiciator for generic Stream, Future, and Poll calls
-let cnt = 0;
-export const STDIN = ++cnt;
-export const STDOUT = ++cnt;
-export const STDERR = ++cnt;
-export const FILE = ++cnt;
-export const HTTP = ++cnt;
-export const SOCKET = ++cnt;
+export const SOCKET_GET_DEFAULT_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_GET_DEFAULT_RECEIVE_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+
+// Name lookup
+export const SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST = ++call_id << CALL_SHIFT;
+export const SOCKET_RESOLVE_ADDRESS_TAKE_REQUEST = ++call_id << CALL_SHIFT;
+export const SOCKET_RESOLVE_ADDRESS_SUBSCRIBE_REQUEST = ++call_id << CALL_SHIFT;
+export const SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST = ++call_id << CALL_SHIFT;
+
+export const reverseMap = {};
+
+import * as calls from "./calls.js";
+
+for (const name of Object.getOwnPropertyNames(calls)) {
+  if (name === "reverseMap") continue;
+  reverseMap[calls[name]] = name;
+}

package/lib/io/worker-http.js

@@ -1,14 +1,96 @@
-import { Readable } from "node:stream";
-import { createStream, getStreamOrThrow } from "./worker-thread.js";
+import {
+  createReadableStream,
+  getStreamOrThrow,
+} from "./worker-thread.js";
+import {
+  createServer,
+  request as httpRequest,
+  Agent as HttpAgent,
+} from "node:http";
+import { request as httpsRequest, Agent as HttpsAgent } from "node:https";
+import { parentPort } from "node:worker_threads";
+import { HTTP_SERVER_INCOMING_HANDLER } from "./calls.js";
 
-export async function createHttpRequest(method, url, headers, bodyId) {
-  let body = null;
+const agentOptions = {
+  keepAlive: true,
+};
+const httpAgent = new HttpAgent(agentOptions);
+const httpsAgent = new HttpsAgent(agentOptions);
+
+const servers = new Map();
+
+let responseCnt = 0;
+const responses = new Map();
+
+export async function stopHttpServer(id) {
+  await new Promise((resolve) => servers.get(id).close(resolve));
+}
+
+export function clearOutgoingResponse(id) {
+  responses.delete(id);
+}
+
+export async function setOutgoingResponse(
+  id,
+  { statusCode, headers, streamId }
+) {
+  const response = responses.get(id);
+  const textDecoder = new TextDecoder();
+  response.writeHead(
+    statusCode,
+    Object.fromEntries(
+      headers.map(([key, val]) => [key, textDecoder.decode(val)])
+    )
+  );
+  response.flushHeaders();
+  const { stream } = getStreamOrThrow(streamId);
+  stream.pipe(response);
+  responses.delete(id);
+}
+
+export async function startHttpServer(id, { port, host }) {
+  const server = createServer((req, res) => {
+    // create the streams and their ids
+    const streamId = createReadableStream(req);
+    const responseId = ++responseCnt;
+    parentPort.postMessage({
+      type: HTTP_SERVER_INCOMING_HANDLER,
+      id,
+      payload: {
+        responseId,
+        method: req.method,
+        host: req.headers.host || host || "localhost",
+        pathWithQuery: req.url,
+        headers: Object.entries(req.headersDistinct).flatMap(([key, val]) =>
+          val.map((val) => [key, val])
+        ),
+        streamId,
+      },
+    });
+    responses.set(responseId, res);
+  });
+  await new Promise((resolve, reject) => {
+    server.listen(port, host, resolve);
+    server.on("error", reject);
+  });
+  servers.set(id, server);
+}
+
+export async function createHttpRequest(
+  method,
+  scheme,
+  authority,
+  pathWithQuery,
+  headers,
+  bodyId,
+  connectTimeout,
+  betweenBytesTimeout,
+  firstByteTimeout
+) {
+  let stream = null;
   if (bodyId) {
     try {
-      const { stream } = getStreamOrThrow(bodyId);
-      body = stream.readableBodyStream;
-      // this indicates we're attached
-      stream.readableBodyStream = null;
+      ({ stream } = getStreamOrThrow(bodyId));
     } catch (e) {
       if (e.tag === "closed")
         throw { tag: "internal-error", val: "Unexpected closed body stream" };
@@ -25,71 +107,86 @@ export async function createHttpRequest(method, url, headers, bodyId) {
     }
   }
   try {
-    const res = await fetch(url, {
-      method,
-      headers: new Headers(headers),
-      body,
-      redirect: "manual",
-      duplex: "half",
+    // Make a request
+    let req;
+    switch (scheme) {
+      case "http:":
+        req = httpRequest({
+          agent: httpAgent,
+          method,
+          host: authority.split(":")[0],
+          port: authority.split(":")[1],
+          path: pathWithQuery,
+          timeout: connectTimeout && Number(connectTimeout),
+        });
+        break;
+      case "https:":
+        req = httpsRequest({
+          agent: httpsAgent,
+          method,
+          host: authority.split(":")[0],
+          port: authority.split(":")[1],
+          path: pathWithQuery,
+          timeout: connectTimeout && Number(connectTimeout),
+        });
+        break;
+      default:
+        throw { tag: "HTTP-protocol-error" };
+    }
+    for (const [key, value] of headers) {
+      req.appendHeader(key, value);
+    }
+    req.flushHeaders();
+    if (stream) {
+      stream.pipe(req);
+    } else {
+      req.end();
+    }
+    const res = await new Promise((resolve, reject) => {
+      req.once("response", resolve);
+      req.once("close", () => reject);
+      req.once("error", reject);
     });
-    const bodyStreamId = createStream(Readable.fromWeb(res.body));
+    if (firstByteTimeout) res.setTimeout(Number(firstByteTimeout));
+    if (betweenBytesTimeout)
+      res.once("readable", () => {
+        res.setTimeout(Number(betweenBytesTimeout));
+      });
+    const bodyStreamId = createReadableStream(res);
     return {
-      status: res.status,
-      headers: Array.from(res.headers),
-      bodyStreamId: bodyStreamId,
+      status: res.statusCode,
+      headers: Array.from(Object.entries(res.headers)),
+      bodyStreamId
     };
   } catch (e) {
-    if (e?.cause) {
-      let err = e.cause;
-      if (e.cause instanceof AggregateError) err = e.cause.errors[0];
-      if (err.message === "unknown scheme")
+    if (e?.tag) throw e;
+    const err = getFirstError(e);
+    switch (err.code) {
+      case "ECONNRESET":
+        throw { tag: "HTTP-protocol-error" };
+      case "ENOTFOUND":
         throw {
-          tag: "HTTP-protocol-error",
+          tag: "DNS-error",
+          val: {
+            rcode: err.code,
+            infoCode: err.errno < 0 ? -err.errno : err.errno,
+          },
+        };
+      case "ECONNREFUSED":
+        throw {
+          tag: "connection-refused",
         };
-      switch (err.syscall) {
-        case "connect": {
-          if (err.code === "ECONNREFUSED")
-            throw {
-              tag: "connection-refused",
-            };
-          break;
-        }
-        case "getaddrinfo": {
-          const { errno, code } = err;
-          throw {
-            tag: "DNS-error",
-            val: {
-              rcode: code,
-              infoCode: errno,
-            },
-          };
-        }
-      }
-    }
-    if (e?.message?.includes("Failed to parse URL")) {
-      throw {
-        tag: "HTTP-request-URI-invalid",
-        val: undefined,
-      };
-    }
-    if (e?.message?.includes("HTTP")) {
-      switch (e?.message.replace(/'[^']+'/, "'{}'")) {
-        case "'{}' HTTP method is unsupported.":
-          throw {
-            tag: "HTTP-protocol-error",
-            val: undefined,
-          };
-        case "'{}' is not a valid HTTP method.":
-          throw {
-            tag: "HTTP-request-method-invalid",
-            val: undefined,
-          };
-      }
-      throw {
-        tag: "internal-error",
-        val: e.toString(),
-      };
     }
-    throw e;
+    throw {
+      tag: "internal-error",
+      val: err.toString(),
+    };
   }
 }
+
+function getFirstError(e) {
+  if (typeof e !== "object" || e === null) return e;
+  if (e.cause) return getFirstError(e.cause);
+  if (e instanceof AggregateError) return getFirstError(e.errors[0]);
+  return e;
+}