smoldot 3.5.0 → 3.7.0

package/dist/cjs/no-auto-bytecode-browser.js

@@ -14,6 +14,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startWithBytecode = exports.QueueFullError = exports.JsonRpcDisabledError = exports.CrashError = exports.AlreadyDestroyedError = exports.AddChainError = void 0;
 const client_js_1 = require("./internals/client.js");
+const dns_over_https_js_1 = require("./internals/dns-over-https.js");
 var public_types_js_1 = require("./public-types.js");
 Object.defineProperty(exports, "AddChainError", { enumerable: true, get: function () { return public_types_js_1.AddChainError; } });
 Object.defineProperty(exports, "AlreadyDestroyedError", { enumerable: true, get: function () { return public_types_js_1.AlreadyDestroyedError; } });
@@ -194,17 +195,46 @@ function connect(config) {
                 openOutSubstream: () => { throw new Error('Connection is closed'); },
             };
         }
-        const { targetPort, ipVersion, targetIp, remoteTlsCertificateSha256 } = config.address;
+        const { targetPort, remoteTlsCertificateSha256 } = config.address;
         const state = {
             pc: undefined,
             dataChannels: new Map(),
             nextStreamId: 0,
             isFirstOutSubstream: true,
+            dnsAbort: null,
         };
+        // The SDP answer needs the literal IP address of the remote.
+        // Browsers expose no DNS API, so a multiaddress with a domain name is resolved over
+        // DNS-over-HTTPS. Resolution is started here and is only awaited in
+        // `onnegotiationneeded`, where the IP is actually needed.
+        let target;
+        if ("targetIp" in config.address) {
+            target = Promise.resolve({ targetIp: config.address.targetIp, ipVersion: config.address.ipVersion });
+        }
+        else {
+            const { hostname, family } = config.address;
+            const controller = new AbortController();
+            state.dnsAbort = controller;
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const finished = () => {
+                clearTimeout(timeout);
+                state.dnsAbort = null;
+            };
+            target = (0, dns_over_https_js_1.resolveDnsOverHttps)(hostname, family, controller.signal).then((ip) => {
+                finished();
+                return { targetIp: ip, ipVersion: ip.includes(':') ? 6 : 4 };
+            }, (error) => {
+                finished();
+                throw error;
+            });
+            target.catch(() => { });
+        }
         // Kills all the JavaScript objects (the connection and all its substreams), ensuring that no
         // callback will be called again. Doesn't report anything to smoldot, as this should be done
         // by the caller.
         const killAllJs = () => {
+            if (state.dnsAbort)
+                state.dnsAbort.abort();
             // The `RTCPeerConnection` is created pretty quickly. It is however still possible for
             // smoldot to cancel the opening, in which case `pc` will still be undefined.
             if (!state.pc) {
@@ -225,6 +255,18 @@ function connect(config) {
             state.dataChannels.clear();
             state.pc.close(); // Not necessarily necessary, but it doesn't hurt to do so.
         };
+        // Due to <https://bugzilla.mozilla.org/show_bug.cgi?id=1659672>,
+        // connections from Firefox to a localhost WebRTC server always fail:
+        // Firefox gathers no loopback ICE candidate.
+        // 
+        // Returns `true` if the connection was refused, in which case the caller must stop.
+        const refuseIfFirefoxLoopback = (ip) => {
+            if ((ip !== '127.0.0.1' && ip !== '::1') || navigator.userAgent.indexOf('Firefox') === -1)
+                return false;
+            killAllJs();
+            config.onConnectionReset("Firefox can't connect to a localhost WebRTC server");
+            return true;
+        };
         // Function that configures a newly-opened channel and adds it to the map. Used for both
         // inbound and outbound substreams.
         const addChannel = (dataChannel, direction) => {
@@ -287,19 +329,10 @@ function connect(config) {
         RTCPeerConnection.generateCertificate({ name: "ECDSA", namedCurve: "P-256", hash: "SHA-256" }).then((localCertificate) => __awaiter(this, void 0, void 0, function* () {
             if (state.pc === null)
                 return;
-            // Due to <https://bugzilla.mozilla.org/show_bug.cgi?id=1659672>, connections from
-            // Firefox to a localhost WebRTC server always fails. Since this bug has been opened
-            // for three years at the time of writing, it is unlikely to be fixed in the short
-            // term. In order to provider better user feedback, we straight up refuse connecting
-            // and stop the connection.
-            // Note that this is just a hint. Failing to detect this will lead to the WebRTC
-            // handshake  timing out.
-            // TODO: eventually remove this if the Firefox bug is fixed
-            if ((targetIp == 'localhost' || targetIp == '127.0.0.1' || targetIp == '::1') && navigator.userAgent.indexOf('Firefox') !== -1) {
-                killAllJs();
-                config.onConnectionReset("Firefox can't connect to a localhost WebRTC server");
+            // A literal loopback address can be refused before anything is created. A domain
+            // name is checked once resolved, in `onnegotiationneeded`.
+            if ("targetIp" in config.address && refuseIfFirefoxLoopback(config.address.targetIp))
                 return;
-            }
             // Create a new WebRTC connection.
             state.pc = new RTCPeerConnection({ certificates: [localCertificate] });
             // We need to build the multihash corresponding to the local certificate.
@@ -374,6 +407,25 @@ function connect(config) {
                 sdpOffer = sdpOffer.replace(/^a=ice-ufrag.*$/m, 'a=ice-ufrag:' + ufragPwd);
                 sdpOffer = sdpOffer.replace(/^a=ice-pwd.*$/m, 'a=ice-pwd:' + ufragPwd);
                 yield state.pc.setLocalDescription({ type: 'offer', sdp: sdpOffer });
+                // The answer needs the literal IP address of the remote, resolution was already stared.
+                let targetIp;
+                let ipVersion;
+                try {
+                    ({ targetIp, ipVersion } = yield target);
+                }
+                catch (error) {
+                    // `reset()` aborts the resolution, and a failure reported through
+                    // `onconnectionstatechange` closes the connection.
+                    if (state.pc.signalingState === "closed")
+                        return;
+                    killAllJs();
+                    config.onConnectionReset("DNS resolution failed: " + (error instanceof Error ? error.message : String(error)));
+                    return;
+                }
+                if (state.pc.signalingState === "closed")
+                    return;
+                if (refuseIfFirefoxLoopback(targetIp))
+                    return;
                 // Transform certificate hash into fingerprint (upper-hex; each byte separated by ":").
                 const fingerprint = Array.from(remoteTlsCertificateSha256).map((n) => ("0" + n.toString(16)).slice(-2).toUpperCase()).join(':');
                 // Note that the trailing line feed is important, as otherwise Chrome

package/dist/cjs/no-auto-bytecode-nodejs.js

@@ -39,6 +39,17 @@ function startWithBytecode(options) {
     });
 }
 exports.startWithBytecode = startWithBytecode;
+/**
+ * Human-readable reason for a socket error. An `AggregateError` (every address of a
+ * multi-address host failed) has an empty `message`; its causes are in `errors`.
+ */
+function errorReason(error) {
+    var _a;
+    return ((_a = error.errors) === null || _a === void 0 ? void 0 : _a.map((cause) => cause.message).filter(Boolean).join("; "))
+        || error.message
+        || error.code
+        || "Error";
+}
 /**
  * Tries to open a new connection using the given configuration.
  *
@@ -86,7 +97,7 @@ function connect(config) {
             socket.onerror = () => { };
         };
         socket.onerror = (event) => {
-            config.onConnectionReset(event.message);
+            config.onConnectionReset(errorReason(event.error));
             socket.onopen = () => { };
             socket.onclose = () => { };
             socket.onmessage = () => { };
@@ -126,30 +137,35 @@ function connect(config) {
         });
         // Number of bytes queued using `socket.write` and where `write` has returned false.
         const drainingBytes = { num: 0 };
+        // Set by `reset()`. Events that arrive after that must be ignored. This can't be
+        // `socket.destroyed`: NodeJS marks the socket destroyed before emitting `close`, so
+        // that check would swallow every close, including remote ones.
+        let resetCalled = false;
+        // Message of the last `error` event, reported through the `close` event that follows it.
+        let lastError = null;
         socket.setNoDelay();
         socket.on('connect', () => {
-            if (socket.destroyed)
+            if (resetCalled)
                 return;
             config.onWritableBytes(socket.writableHighWaterMark);
         });
+        socket.on('error', (error) => {
+            lastError = errorReason(error);
+        });
         socket.on('close', (hasError) => {
-            if (socket.destroyed)
+            if (resetCalled)
                 return;
-            // NodeJS doesn't provide a reason why the closing happened, but only
-            // whether it was caused by an error.
-            const message = hasError ? "Error" : "Closed gracefully";
-            config.onConnectionReset(message);
+            config.onConnectionReset(lastError !== null && lastError !== void 0 ? lastError : (hasError ? "Error" : "Closed gracefully"));
         });
-        socket.on('error', () => { });
         socket.on('data', (message) => {
-            if (socket.destroyed)
+            if (resetCalled)
                 return;
             config.onMessage(new Uint8Array(message.buffer));
         });
         socket.on('drain', () => {
             // The bytes queued using `socket.write` and where `write` has returned false have now
             // been sent. Notify the API that it can write more data.
-            if (socket.destroyed)
+            if (resetCalled)
                 return;
             const val = drainingBytes.num;
             drainingBytes.num = 0;
@@ -157,6 +173,7 @@ function connect(config) {
         });
         return {
             reset: () => {
+                resetCalled = true;
                 socket.destroy();
             },
             send: (data) => {