smoldot 2.0.8 → 2.0.10

package/dist/cjs/internals/client.d.ts

@@ -140,7 +140,7 @@ export interface ConnectionConfig {
      *
      * This function must only be called for connections of type "multi-stream".
      */
-    onStreamReset: (streamId: number) => void;
+    onStreamReset: (streamId: number, message: string) => void;
     /**
      * Callback called when some data sent using {@link Connection.send} has effectively been
      * written on the stream, meaning that some buffer space is now free.

package/dist/cjs/internals/client.js

@@ -153,10 +153,10 @@ function start(options, wasmModule, platformBindings) {
                             throw new Error();
                         state.instance.instance.streamWritableBytes(connectionId, numExtra, streamId);
                     },
-                    onStreamReset(streamId) {
+                    onStreamReset(streamId, message) {
                         if (state.instance.status !== "ready")
                             throw new Error();
-                        state.instance.instance.streamReset(connectionId, streamId);
+                        state.instance.instance.streamReset(connectionId, streamId, message);
                     },
                 }));
                 break;

package/dist/cjs/internals/local-instance.d.ts

@@ -111,7 +111,7 @@ export interface Instance {
     streamWritableBytes: (connectionId: number, numExtra: number, streamId?: number) => void;
     streamMessage: (connectionId: number, message: Uint8Array, streamId?: number) => void;
     streamOpened: (connectionId: number, streamId: number, direction: 'inbound' | 'outbound') => void;
-    streamReset: (connectionId: number, streamId: number) => void;
+    streamReset: (connectionId: number, streamId: number, message: string) => void;
 }
 /**
  * Starts a new instance using the given configuration.

package/dist/cjs/internals/local-instance.js

@@ -438,10 +438,12 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                     return;
                 state.instance.exports.connection_stream_opened(connectionId, streamId, direction === 'outbound' ? 1 : 0);
             },
-            streamReset: (connectionId, streamId) => {
+            streamReset: (connectionId, streamId, message) => {
                 if (!state.instance)
                     return;
-                state.instance.exports.stream_reset(connectionId, streamId);
+                state.bufferIndices[0] = new TextEncoder().encode(message);
+                state.instance.exports.stream_reset(connectionId, streamId, 0);
+                delete state.bufferIndices[0];
             },
         };
     });

package/dist/cjs/internals/remote-instance.js

@@ -196,9 +196,9 @@ function connectToInstanceServer(config) {
                 const msg = { ty: "stream-writable-bytes", connectionId, numExtra, streamId };
                 portToServer.postMessage(msg);
             },
-            streamReset(connectionId, streamId) {
+            streamReset(connectionId, streamId, message) {
                 state.connections.get(connectionId).delete(streamId);
-                const msg = { ty: "stream-reset", connectionId, streamId };
+                const msg = { ty: "stream-reset", connectionId, streamId, message };
                 portToServer.postMessage(msg);
             },
         };
@@ -333,7 +333,7 @@ function startInstanceServer(config, initPortToClient) {
                     if (!state.connections.has(message.connectionId))
                         return;
                     // The stream might have been reset locally in the past.
-                    if (message.streamId && !state.connections.get(message.connectionId).has(message.streamId))
+                    if (message.streamId !== undefined && !state.connections.get(message.connectionId).has(message.streamId))
                         return;
                     state.instance.streamMessage(message.connectionId, message.message, message.streamId);
                     break;
@@ -351,7 +351,7 @@ function startInstanceServer(config, initPortToClient) {
                     if (!state.connections.has(message.connectionId))
                         return;
                     // The stream might have been reset locally in the past.
-                    if (message.streamId && !state.connections.get(message.connectionId).has(message.streamId))
+                    if (message.streamId !== undefined && !state.connections.get(message.connectionId).has(message.streamId))
                         return;
                     state.instance.streamWritableBytes(message.connectionId, message.numExtra, message.streamId);
                     break;
@@ -361,10 +361,10 @@ function startInstanceServer(config, initPortToClient) {
                     if (!state.connections.has(message.connectionId))
                         return;
                     // The stream might have been reset locally in the past.
-                    if (message.streamId && !state.connections.get(message.connectionId).has(message.streamId))
+                    if (!state.connections.get(message.connectionId).has(message.streamId))
                         return;
                     state.connections.get(message.connectionId).delete(message.streamId);
-                    state.instance.streamReset(message.connectionId, message.streamId);
+                    state.instance.streamReset(message.connectionId, message.streamId, message.message);
                     break;
                 }
             }

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

@@ -155,56 +155,52 @@ function connect(config) {
     }
     else if (config.address.ty === "webrtc") {
         const { targetPort, ipVersion, targetIp, remoteTlsCertificateSha256 } = config.address;
-        // TODO: detect localhost for Firefox? https://bugzilla.mozilla.org/show_bug.cgi?id=1659672
-        // Note that `pc` can be the connection, but also null or undefined.
-        // `undefined` means "certificate generation in progress", while `null` means "opening must
-        // be cancelled".
-        // While it would be better to use for example a string instead of `null`, using `null` lets
-        // us use the `!` operator more easily and leads to more readable code.
-        let pc = undefined;
-        // Contains the data channels that are open and have been reported to smoldot.
-        const dataChannels = new Map();
-        // SHA256 hash of the DTLS certificate of the local node. Unknown as long as it hasn't been
-        // generated.
-        // TODO: could be merged with `pc` in one variable, and maybe even the other fields as well
-        let localTlsCertificateSha256;
+        const state = {
+            pc: undefined,
+            dataChannels: new Map(),
+            nextStreamId: 0,
+            isFirstOutSubstream: true,
+        };
         // 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 = () => {
             // 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 (!pc) {
-                console.assert(dataChannels.size === 0, "substreams exist while pc is undef");
-                pc = null;
+            if (!state.pc) {
+                console.assert(state.dataChannels.size === 0, "substreams exist while pc is undef");
+                state.pc = null;
                 return;
             }
-            pc.onconnectionstatechange = null;
-            pc.onnegotiationneeded = null;
-            pc.ondatachannel = null;
-            for (const channel of Array.from(dataChannels.values())) {
+            state.pc.onconnectionstatechange = null;
+            state.pc.onnegotiationneeded = null;
+            state.pc.ondatachannel = null;
+            for (const channel of Array.from(state.dataChannels.values())) {
                 channel.channel.onopen = null;
                 channel.channel.onerror = null;
                 channel.channel.onclose = null;
                 channel.channel.onbufferedamountlow = null;
                 channel.channel.onmessage = null;
             }
-            dataChannels.clear();
-            pc.close(); // Not necessarily necessary, but it doesn't hurt to do so.
+            state.dataChannels.clear();
+            state.pc.close(); // Not necessarily necessary, but it doesn't hurt to do so.
         };
         // Function that configures a newly-opened channel and adds it to the map. Used for both
         // inbound and outbound substreams.
         const addChannel = (dataChannel, direction) => {
-            const dataChannelId = dataChannel.id;
+            const streamId = state.nextStreamId;
+            state.nextStreamId += 1;
             dataChannel.binaryType = 'arraybuffer';
             let isOpen = { value: false };
             dataChannel.onopen = () => {
                 console.assert(!isOpen.value, "substream opened twice");
                 isOpen.value = true;
-                config.onStreamOpened(dataChannelId, direction);
-                config.onWritableBytes(65536, dataChannelId);
+                config.onStreamOpened(streamId, direction);
+                config.onWritableBytes(65536, streamId);
             };
-            dataChannel.onerror = dataChannel.onclose = (_error) => {
+            dataChannel.onerror = dataChannel.onclose = (event) => {
+                // Note that Firefox doesn't support <https://developer.mozilla.org/en-US/docs/Web/API/RTCErrorEvent>.
+                const message = (event instanceof RTCErrorEvent) ? event.error.toString() : "RTCDataChannel closed";
                 if (!isOpen.value) {
                     // Substream wasn't opened yet and thus has failed to open. The API has no
                     // mechanism to report substream openings failures. We could try opening it
@@ -212,24 +208,30 @@ function connect(config) {
                     // entire connection.
                     killAllJs();
                     // Note that the event doesn't give any additional reason for the failure.
-                    config.onConnectionReset("data channel failed to open");
+                    config.onConnectionReset("data channel failed to open: " + message);
                 }
                 else {
                     // Substream was open and is now closed. Normal situation.
-                    config.onStreamReset(dataChannelId);
+                    dataChannel.onopen = null;
+                    dataChannel.onerror = null;
+                    dataChannel.onclose = null;
+                    dataChannel.onbufferedamountlow = null;
+                    dataChannel.onmessage = null;
+                    state.dataChannels.delete(streamId);
+                    config.onStreamReset(streamId, message);
                 }
             };
             dataChannel.onbufferedamountlow = () => {
-                const channel = dataChannels.get(dataChannelId);
+                const channel = state.dataChannels.get(streamId);
                 const val = channel.bufferedBytes;
                 channel.bufferedBytes = 0;
-                config.onWritableBytes(val, dataChannelId);
+                config.onWritableBytes(val, streamId);
             };
             dataChannel.onmessage = (m) => {
                 // The `data` field is an `ArrayBuffer`.
-                config.onMessage(new Uint8Array(m.data), dataChannelId);
+                config.onMessage(new Uint8Array(m.data), streamId);
             };
-            dataChannels.set(dataChannelId, { channel: dataChannel, bufferedBytes: 0 });
+            state.dataChannels.set(streamId, { channel: dataChannel, bufferedBytes: 0 });
         };
         // It is possible for the browser to use multiple different certificates.
         // In order for our local certificate to be deterministic, we need to generate it manually and
@@ -237,10 +239,23 @@ function connect(config) {
         // According to <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-generatecertificate>,
         // browsers are guaranteed to support `{ name: "ECDSA", namedCurve: "P-256" }`.
         RTCPeerConnection.generateCertificate({ name: "ECDSA", namedCurve: "P-256", hash: "SHA-256" }).then((localCertificate) => __awaiter(this, void 0, void 0, function* () {
-            if (pc === null)
+            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");
                 return;
+            }
             // Create a new WebRTC connection.
-            pc = new RTCPeerConnection({ certificates: [localCertificate] });
+            state.pc = new RTCPeerConnection({ certificates: [localCertificate] });
             // We need to build the multihash corresponding to the local certificate.
             // While there exists a `RTCPeerConnection.getFingerprints` function, Firefox notably
             // doesn't support it.
@@ -263,7 +278,7 @@ function connect(config) {
                 }
             }
             else {
-                const localSdpOffer = yield pc.createOffer();
+                const localSdpOffer = yield state.pc.createOffer();
                 // Note that this regex is not strict. The browser isn't a malicious actor, and the
                 // objective of this regex is not to detect invalid input.
                 const localSdpOfferFingerprintMatch = localSdpOffer.sdp.match(/a(\s*)=(\s*)fingerprint:(\s*)(sha|SHA)-256(\s*)(([a-fA-F0-9]{2}(:)*){32})/);
@@ -277,23 +292,23 @@ function connect(config) {
                 config.onConnectionReset('Failed to obtain the browser certificate fingerprint');
                 return;
             }
-            localTlsCertificateSha256 = new Uint8Array(32);
+            let localTlsCertificateSha256 = new Uint8Array(32);
             localTlsCertificateSha256.set(localTlsCertificateHex.split(':').map((s) => parseInt(s, 16)), 0);
             // `onconnectionstatechange` is used to detect when the connection has closed or has failed
             // to open.
             // Note that smoldot will think that the connection is open even when it is still opening.
             // Therefore we don't care about events concerning the fact that the connection is now fully
             // open.
-            pc.onconnectionstatechange = (_event) => {
-                if (pc.connectionState == "closed" || pc.connectionState == "disconnected" || pc.connectionState == "failed") {
+            state.pc.onconnectionstatechange = (_event) => {
+                if (state.pc.connectionState == "closed" || state.pc.connectionState == "disconnected" || state.pc.connectionState == "failed") {
                     killAllJs();
-                    config.onConnectionReset("WebRTC state transitioned to " + pc.connectionState);
+                    config.onConnectionReset("WebRTC state transitioned to " + state.pc.connectionState);
                 }
             };
-            pc.onnegotiationneeded = (_event) => __awaiter(this, void 0, void 0, function* () {
+            state.pc.onnegotiationneeded = (_event) => __awaiter(this, void 0, void 0, function* () {
                 var _a;
                 // Create a new offer and set it as local description.
-                let sdpOffer = (yield pc.createOffer()).sdp;
+                let sdpOffer = (yield state.pc.createOffer()).sdp;
                 // We check that the locally-generated SDP offer has a data channel with the UDP
                 // protocol. If that isn't the case, the connection will likely fail.
                 if (sdpOffer.match(/^m=application(\s+)(\d+)(\s+)UDP\/DTLS\/SCTP(\s+)webrtc-datachannel$/m) === null) {
@@ -312,7 +327,7 @@ function connect(config) {
                 const ufragPwd = "libp2p+webrtc+v1/" + browserGeneratedPwd;
                 sdpOffer = sdpOffer.replace(/^a=ice-ufrag.*$/m, 'a=ice-ufrag:' + ufragPwd);
                 sdpOffer = sdpOffer.replace(/^a=ice-pwd.*$/m, 'a=ice-pwd:' + ufragPwd);
-                yield pc.setLocalDescription({ type: 'offer', sdp: sdpOffer });
+                yield state.pc.setLocalDescription({ type: 'offer', sdp: sdpOffer });
                 // 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
@@ -373,9 +388,9 @@ function connect(config) {
                     // A transport address for a candidate that can be used for connectivity
                     // checks (RFC8839).
                     "a=candidate:1 1 UDP 1 " + targetIp + " " + String(targetPort) + " typ host" + "\n";
-                yield pc.setRemoteDescription({ type: "answer", sdp: remoteSdp });
+                yield state.pc.setRemoteDescription({ type: "answer", sdp: remoteSdp });
             });
-            pc.ondatachannel = ({ channel }) => {
+            state.pc.ondatachannel = ({ channel }) => {
                 // TODO: is the substream maybe already open? according to the Internet it seems that no but it's unclear
                 addChannel(channel, 'inbound');
             };
@@ -391,18 +406,18 @@ function connect(config) {
                     killAllJs();
                 }
                 else {
-                    const channel = dataChannels.get(streamId);
+                    const channel = state.dataChannels.get(streamId);
                     channel.channel.onopen = null;
                     channel.channel.onerror = null;
                     channel.channel.onclose = null;
                     channel.channel.onbufferedamountlow = null;
                     channel.channel.onmessage = null;
                     channel.channel.close();
-                    dataChannels.delete(streamId);
+                    state.dataChannels.delete(streamId);
                 }
             },
             send: (data, streamId) => {
-                const channel = dataChannels.get(streamId);
+                const channel = state.dataChannels.get(streamId);
                 channel.channel.send(data);
                 channel.bufferedBytes += data.length;
             },
@@ -412,7 +427,10 @@ function connect(config) {
                 // therefore `pc` is guaranteed to be non-null.
                 // Note that the label passed to `createDataChannel` is required to be empty as
                 // per the libp2p WebRTC specification.
-                addChannel(pc.createDataChannel(""), 'outbound');
+                // TODO: adjusting the options based on the first substream is a bit hacky
+                const opts = state.isFirstOutSubstream ? { negotiated: true, id: 0 } : {};
+                state.isFirstOutSubstream = false;
+                addChannel(state.pc.createDataChannel("", opts), 'outbound');
             }
         };
     }