@bytecodealliance/preview2-shim 0.17.1 → 0.17.3

package/lib/io/worker-sockets.js

@@ -1,37 +1,37 @@
-import { isIP } from "node:net";
-import { lookup } from "node:dns/promises";
-import { Socket } from "node:dgram";
+import { isIP } from 'node:net';
+import { lookup } from 'node:dns/promises';
+import { Socket } from 'node:dgram';
 import {
-  ALL,
-  BADFAMILY,
-  CANCELLED,
-  CONNREFUSED,
-  NODATA,
-  NOMEM,
-  NONAME,
-  NOTFOUND,
-  REFUSED,
-  SERVFAIL,
-  TIMEOUT,
-  V4MAPPED,
-} from "node:dns";
+    ALL,
+    BADFAMILY,
+    CANCELLED,
+    CONNREFUSED,
+    NODATA,
+    NOMEM,
+    NONAME,
+    NOTFOUND,
+    REFUSED,
+    SERVFAIL,
+    TIMEOUT,
+    V4MAPPED,
+} from 'node:dns';
 import {
-  EACCES,
-  EADDRINUSE,
-  EADDRNOTAVAIL,
-  EALREADY,
-  EBADF,
-  ECONNABORTED,
-  ECONNREFUSED,
-  ECONNRESET,
-  EINVAL,
-  ENOBUFS,
-  ENOMEM,
-  ENOTCONN,
-  ENOTSUP,
-  EPERM,
-  EWOULDBLOCK,
-} from "node:constants";
+    EACCES,
+    EADDRINUSE,
+    EADDRNOTAVAIL,
+    EALREADY,
+    EBADF,
+    ECONNABORTED,
+    ECONNREFUSED,
+    ECONNRESET,
+    EINVAL,
+    ENOBUFS,
+    ENOMEM,
+    ENOTCONN,
+    ENOTSUP,
+    EPERM,
+    EWOULDBLOCK,
+} from 'node:constants';
 
 let stateCnt = 0;
 export const SOCKET_STATE_INIT = ++stateCnt;
@@ -44,157 +44,164 @@ export const SOCKET_STATE_CONNECTION = ++stateCnt;
 export const SOCKET_STATE_CLOSED = ++stateCnt;
 
 const dnsLookupOptions = {
-  verbatim: true,
-  all: true,
-  hints: V4MAPPED | ALL,
+    verbatim: true,
+    all: true,
+    hints: V4MAPPED | ALL,
 };
 
 export function noLookup(ip, _opts, cb) {
-  cb(null, ip);
+    cb(null, ip);
 }
 
 export function socketResolveAddress(name) {
-  const isIpNum = isIP(
-    name[0] === "[" && name[name.length - 1] === "]" ? name.slice(1, -1) : name
-  );
-  if (isIpNum > 0) {
-    return Promise.resolve([
-      {
-        tag: "ipv" + isIpNum,
-        val: (isIpNum === 4 ? ipv4ToTuple : ipv6ToTuple)(name),
-      },
-    ]);
-  }
-  // verify it is a valid domain name using the URL parser
-  let parsedUrl = null;
-  try {
-    parsedUrl = new URL(`https://${name}`);
-    if (
-      parsedUrl.port.length ||
-      parsedUrl.username.length ||
-      parsedUrl.password.length ||
-      parsedUrl.pathname !== "/" ||
-      parsedUrl.search.length ||
-      parsedUrl.hash.length
-    )
-      parsedUrl = null;
-  } catch {
-    // empty
-  }
-  if (!parsedUrl) throw "invalid-argument";
-
-  return lookup(name, dnsLookupOptions).then(
-    (addresses) => {
-      return addresses.map(({ address, family }) => {
-        [
-          {
-            tag: "ipv" + family,
-            val: (family === 4 ? ipv4ToTuple : ipv6ToTuple)(address),
-          },
-        ];
-      });
-    },
-    (err) => {
-      switch (err.code) {
-        // TODO: verify these more carefully
-        case NODATA:
-        case BADFAMILY:
-        case NONAME:
-        case NOTFOUND:
-          throw "name-unresolvable";
-        case TIMEOUT:
-        case REFUSED:
-        case CONNREFUSED:
-        case SERVFAIL:
-        case NOMEM:
-        case CANCELLED:
-          throw "temporary-resolver-failure";
-        default:
-          throw "permanent-resolver-failure";
-      }
+    const isIpNum = isIP(
+        name[0] === '[' && name[name.length - 1] === ']'
+            ? name.slice(1, -1)
+            : name
+    );
+    if (isIpNum > 0) {
+        return Promise.resolve([
+            {
+                tag: 'ipv' + isIpNum,
+                val: (isIpNum === 4 ? ipv4ToTuple : ipv6ToTuple)(name),
+            },
+        ]);
+    }
+    // verify it is a valid domain name using the URL parser
+    let parsedUrl = null;
+    try {
+        parsedUrl = new URL(`https://${name}`);
+        if (
+            parsedUrl.port.length ||
+            parsedUrl.username.length ||
+            parsedUrl.password.length ||
+            parsedUrl.pathname !== '/' ||
+            parsedUrl.search.length ||
+            parsedUrl.hash.length
+        ) {
+            parsedUrl = null;
+        }
+    } catch {
+        // empty
     }
-  );
+    if (!parsedUrl) {
+        throw 'invalid-argument';
+    }
+
+    return lookup(name, dnsLookupOptions).then(
+        (addresses) => {
+            return addresses.map(({ address, family }) => {
+                [
+                    {
+                        tag: 'ipv' + family,
+                        val: (family === 4 ? ipv4ToTuple : ipv6ToTuple)(
+                            address
+                        ),
+                    },
+                ];
+            });
+        },
+        (err) => {
+            switch (err.code) {
+                // TODO: verify these more carefully
+                case NODATA:
+                case BADFAMILY:
+                case NONAME:
+                case NOTFOUND:
+                    throw 'name-unresolvable';
+                case TIMEOUT:
+                case REFUSED:
+                case CONNREFUSED:
+                case SERVFAIL:
+                case NOMEM:
+                case CANCELLED:
+                    throw 'temporary-resolver-failure';
+                default:
+                    throw 'permanent-resolver-failure';
+            }
+        }
+    );
 }
 
 export function convertSocketError(err) {
-  switch (err?.code) {
-    case "EBADF":
-    case "ENOTCONN":
-    case "ERR_SOCKET_DGRAM_NOT_CONNECTED":
-      return "invalid-state";
-    case "EACCES":
-    case "EPERM":
-      return "access-denied";
-    case "ENOTSUP":
-      return "not-supported";
-    case "EINVAL":
-      return "invalid-argument";
-    case "ENOMEM":
-    case "ENOBUFS":
-      return "out-of-memory";
-    case "EALREADY":
-      return "concurrency-conflict";
-    case "EWOULDBLOCK":
-      return "would-block";
-    // TODO: return "new-socket-limit";
-    case "EADDRNOTAVAIL":
-      return "address-not-bindable";
-    case "EADDRINUSE":
-      return "address-in-use";
-    // TODO: return "remote-unreachable";
-    case "ECONNREFUSED":
-      return "connection-refused";
-    case "ECONNRESET":
-      return "connection-reset";
-    case "ECONNABORTED":
-      return "connection-aborted";
-    default:
-      return "unknown";
-  }
+    switch (err?.code) {
+        case 'EBADF':
+        case 'ENOTCONN':
+        case 'ERR_SOCKET_DGRAM_NOT_CONNECTED':
+            return 'invalid-state';
+        case 'EACCES':
+        case 'EPERM':
+            return 'access-denied';
+        case 'ENOTSUP':
+            return 'not-supported';
+        case 'EINVAL':
+            return 'invalid-argument';
+        case 'ENOMEM':
+        case 'ENOBUFS':
+            return 'out-of-memory';
+        case 'EALREADY':
+            return 'concurrency-conflict';
+        case 'EWOULDBLOCK':
+            return 'would-block';
+        // TODO: return "new-socket-limit";
+        case 'EADDRNOTAVAIL':
+            return 'address-not-bindable';
+        case 'EADDRINUSE':
+            return 'address-in-use';
+        // TODO: return "remote-unreachable";
+        case 'ECONNREFUSED':
+            return 'connection-refused';
+        case 'ECONNRESET':
+            return 'connection-reset';
+        case 'ECONNABORTED':
+            return 'connection-aborted';
+        default:
+            return 'unknown';
+    }
 }
 
 export function convertSocketErrorCode(code) {
-  switch (code) {
-    case 4053: // windows
-    case 4083:
-    case ENOTCONN:
-    case EBADF:
-      return "invalid-state";
-    case EACCES:
-    case EPERM:
-      return "access-denied";
-    case ENOTSUP:
-      return "not-supported";
-    case EINVAL:
-      return "invalid-argument";
-    case ENOMEM:
-    case ENOBUFS:
-      return "out-of-memory";
-    case EALREADY:
-      return "concurrency-conflict";
-    case EWOULDBLOCK:
-      return "would-block";
-    // TODO: return "new-socket-limit";
-    case 4090: // windows
-    case EADDRNOTAVAIL:
-      return "address-not-bindable";
-    case 4091: // windows
-    case EADDRINUSE:
-      return "address-in-use";
-    // TODO: return "remote-unreachable";
-    case ECONNREFUSED:
-      return "connection-refused";
-    case ECONNRESET:
-      return "connection-reset";
-    case ECONNABORTED:
-      return "connection-aborted";
-    // TODO: return "datagram-too-large";
-    // TODO: return "name-unresolvable";
-    // TODO: return "temporary-resolver-failure";
-    default:
-      // process._rawDebug('unknown error code', code);
-      return "unknown";
-  }
+    switch (code) {
+        case 4053: // windows
+        case 4083:
+        case ENOTCONN:
+        case EBADF:
+            return 'invalid-state';
+        case EACCES:
+        case EPERM:
+            return 'access-denied';
+        case ENOTSUP:
+            return 'not-supported';
+        case EINVAL:
+            return 'invalid-argument';
+        case ENOMEM:
+        case ENOBUFS:
+            return 'out-of-memory';
+        case EALREADY:
+            return 'concurrency-conflict';
+        case EWOULDBLOCK:
+            return 'would-block';
+        // TODO: return "new-socket-limit";
+        case 4090: // windows
+        case EADDRNOTAVAIL:
+            return 'address-not-bindable';
+        case 4091: // windows
+        case EADDRINUSE:
+            return 'address-in-use';
+        // TODO: return "remote-unreachable";
+        case ECONNREFUSED:
+            return 'connection-refused';
+        case ECONNRESET:
+            return 'connection-reset';
+        case ECONNABORTED:
+            return 'connection-aborted';
+        // TODO: return "datagram-too-large";
+        // TODO: return "name-unresolvable";
+        // TODO: return "temporary-resolver-failure";
+        default:
+            // process._rawDebug('unknown error code', code);
+            return 'unknown';
+    }
 }
 
 /**
@@ -205,17 +212,17 @@ export function convertSocketErrorCode(code) {
  */
 
 export function tupleToIPv6(arr) {
-  if (arr.length !== 8) {
-    return null;
-  }
-  return arr.map((segment) => segment.toString(16)).join(":");
+    if (arr.length !== 8) {
+        return null;
+    }
+    return arr.map((segment) => segment.toString(16)).join(':');
 }
 
 export function tupleToIpv4(arr) {
-  if (arr.length !== 4) {
-    return null;
-  }
-  return arr.map((segment) => segment.toString(10)).join(".");
+    if (arr.length !== 4) {
+        return null;
+    }
+    return arr.map((segment) => segment.toString(10)).join('.');
 }
 
 /**
@@ -223,12 +230,12 @@ export function tupleToIpv4(arr) {
  * @returns {boolean}
  */
 export function isMulticastIpAddress(ipSocketAddress) {
-  return (
-    (ipSocketAddress.tag === "ipv4" &&
-      ipSocketAddress.val.address[0] === 0xe0) ||
-    (ipSocketAddress.tag === "ipv6" &&
-      ipSocketAddress.val.address[0] === 0xff00)
-  );
+    return (
+        (ipSocketAddress.tag === 'ipv4' &&
+            ipSocketAddress.val.address[0] === 0xe0) ||
+        (ipSocketAddress.tag === 'ipv6' &&
+            ipSocketAddress.val.address[0] === 0xff00)
+    );
 }
 
 /**
@@ -236,9 +243,10 @@ export function isMulticastIpAddress(ipSocketAddress) {
  * @returns {boolean}
  */
 export function isIPv4MappedAddress(ipSocketAddress) {
-  return (
-    ipSocketAddress.tag === "ipv6" && ipSocketAddress.val.address[5] === 0xffff
-  );
+    return (
+        ipSocketAddress.tag === 'ipv6' &&
+        ipSocketAddress.val.address[5] === 0xffff
+    );
 }
 
 /**
@@ -246,10 +254,10 @@ export function isIPv4MappedAddress(ipSocketAddress) {
  * @returns {boolean}
  */
 export function isUnicastIpAddress(ipSocketAddress) {
-  return (
-    !isMulticastIpAddress(ipSocketAddress) &&
-    !isBroadcastIpAddress(ipSocketAddress)
-  );
+    return (
+        !isMulticastIpAddress(ipSocketAddress) &&
+        !isBroadcastIpAddress(ipSocketAddress)
+    );
 }
 
 /**
@@ -257,25 +265,26 @@ export function isUnicastIpAddress(ipSocketAddress) {
  * @returns {boolean}
  */
 export function isWildcardAddress(ipSocketAddress) {
-  const { address } = ipSocketAddress.val;
-  if (ipSocketAddress.tag === "ipv4")
-    return (
-      address[0] === 0 &&
-      address[1] === 0 &&
-      address[2] === 0 &&
-      address[3] === 0
-    );
-  else
-    return (
-      address[0] === 0 &&
-      address[1] === 0 &&
-      address[2] === 0 &&
-      address[3] === 0 &&
-      address[4] === 0 &&
-      address[5] === 0 &&
-      address[6] === 0 &&
-      address[7] === 0
-    );
+    const { address } = ipSocketAddress.val;
+    if (ipSocketAddress.tag === 'ipv4') {
+        return (
+            address[0] === 0 &&
+            address[1] === 0 &&
+            address[2] === 0 &&
+            address[3] === 0
+        );
+    } else {
+        return (
+            address[0] === 0 &&
+            address[1] === 0 &&
+            address[2] === 0 &&
+            address[3] === 0 &&
+            address[4] === 0 &&
+            address[5] === 0 &&
+            address[6] === 0 &&
+            address[7] === 0
+        );
+    }
 }
 
 /**
@@ -283,14 +292,14 @@ export function isWildcardAddress(ipSocketAddress) {
  * @returns {boolean}
  */
 export function isBroadcastIpAddress(ipSocketAddress) {
-  const { address } = ipSocketAddress.val;
-  return (
-    ipSocketAddress.tag === "ipv4" &&
-    address[0] === 0xff &&
-    address[1] === 0xff &&
-    address[2] === 0xff &&
-    address[3] === 0xff
-  );
+    const { address } = ipSocketAddress.val;
+    return (
+        ipSocketAddress.tag === 'ipv4' &&
+        address[0] === 0xff &&
+        address[1] === 0xff &&
+        address[2] === 0xff &&
+        address[3] === 0xff
+    );
 }
 
 /**
@@ -300,23 +309,25 @@ export function isBroadcastIpAddress(ipSocketAddress) {
  * @returns {string}
  */
 export function serializeIpAddress(addr) {
-  if (addr.tag === "ipv4") return tupleToIpv4(addr.val.address);
-  return tupleToIPv6(addr.val.address);
+    if (addr.tag === 'ipv4') {
+        return tupleToIpv4(addr.val.address);
+    }
+    return tupleToIPv6(addr.val.address);
 }
 
 export function ipv6ToTuple(ipv6) {
-  const [lhs, rhs = ""] = ipv6.includes("::") ? ipv6.split("::") : [ipv6];
-  const lhsParts = lhs === "" ? [] : lhs.split(":");
-  const rhsParts = rhs === "" ? [] : rhs.split(":");
-  return [
-    ...lhsParts,
-    ...Array(8 - lhsParts.length - rhsParts.length).fill(0),
-    ...rhsParts,
-  ].map((segment) => parseInt(segment, 16));
+    const [lhs, rhs = ''] = ipv6.includes('::') ? ipv6.split('::') : [ipv6];
+    const lhsParts = lhs === '' ? [] : lhs.split(':');
+    const rhsParts = rhs === '' ? [] : rhs.split(':');
+    return [
+        ...lhsParts,
+        ...Array(8 - lhsParts.length - rhsParts.length).fill(0),
+        ...rhsParts,
+    ].map((segment) => parseInt(segment, 16));
 }
 
 export function ipv4ToTuple(ipv4) {
-  return ipv4.split(".").map((segment) => parseInt(segment, 10));
+    return ipv4.split('.').map((segment) => parseInt(segment, 10));
 }
 
 /**
@@ -326,46 +337,49 @@ export function ipv4ToTuple(ipv4) {
  * @returns {IpSocketAddress}
  */
 export function ipSocketAddress(family, addr, port) {
-  if (family === "ipv4")
+    if (family === 'ipv4') {
+        return {
+            tag: 'ipv4',
+            val: {
+                port,
+                address: ipv4ToTuple(addr),
+            },
+        };
+    }
     return {
-      tag: "ipv4",
-      val: {
-        port,
-        address: ipv4ToTuple(addr)
-      }
+        tag: 'ipv6',
+        val: {
+            port,
+            flowInfo: 0,
+            address: ipv6ToTuple(addr),
+            scopeId: 0,
+        },
     };
-  return {
-    tag: "ipv6",
-    val: {
-      port,
-      flowInfo: 0,
-      address: ipv6ToTuple(addr),
-      scopeId: 0
-    }
-  };
 }
 
 let _recvBufferSize, _sendBufferSize;
-async function getDefaultBufferSizes () {
-  var s = new Socket({ type: 'udp4' });
-  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();
+async function getDefaultBufferSizes() {
+    var s = new Socket({ type: 'udp4' });
+    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 getDefaultSendBufferSize() {
+    if (!_sendBufferSize) {
+        await getDefaultBufferSizes();
+    }
+    return _sendBufferSize;
 }
 
-export async function getDefaultReceiveBufferSize () {
-  if (!_recvBufferSize)
-    await getDefaultBufferSizes();
-  return _recvBufferSize;
+export async function getDefaultReceiveBufferSize() {
+    if (!_recvBufferSize) {
+        await getDefaultBufferSizes();
+    }
+    return _recvBufferSize;
 }