smoldot 2.0.9 → 2.0.11

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

@@ -68,7 +68,7 @@ export interface Connection {
      *
      * Must not be called after `closeSend` has been called.
      */
-    send(data: Uint8Array, streamId?: number): void;
+    send(data: Array<Uint8Array>, streamId?: number): void;
     /**
      * Closes the writing side of the given stream of the given connection.
      *
@@ -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

@@ -69,7 +69,7 @@ export type Event = {
     ty: "stream-send";
     connectionId: number;
     streamId?: number;
-    data: Uint8Array;
+    data: Array<Uint8Array>;
 } | {
     ty: "stream-send-close";
     connectionId: number;
@@ -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

@@ -250,9 +250,15 @@ function startLocalInstance(config, wasmModule, eventCallback) {
             // that this function is called only when the connection is in an open state.
             stream_send: (connectionId, streamId, ptr, len) => {
                 const instance = state.instance;
+                const mem = new Uint8Array(instance.exports.memory.buffer);
                 ptr >>>= 0;
                 len >>>= 0;
-                const data = new Uint8Array(instance.exports.memory.buffer).slice(ptr, ptr + len);
+                const data = new Array();
+                for (let i = 0; i < len; ++i) {
+                    const bufPtr = buffer.readUInt32LE(mem, ptr + 8 * i);
+                    const bufLen = buffer.readUInt32LE(mem, ptr + 8 * i + 4);
+                    data.push(mem.slice(bufPtr, bufPtr + bufLen));
+                }
                 // TODO: docs says the streamId is provided only for multi-stream connections, but here it's always provided
                 eventCallback({ ty: "stream-send", connectionId, streamId, data });
             },
@@ -438,10 +444,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

@@ -29,6 +29,19 @@ Object.defineProperty(exports, "QueueFullError", { enumerable: true, get: functi
  */
 function startWithBytecode(options) {
     options.forbidTcp = true;
+    // When in a secure context, browsers refuse to open non-secure WebSocket connections to
+    // non-localhost. There is an exception if the page is localhost, in which case all connections
+    // are allowed.
+    // Detecting this ahead of time is better for the overall health of the client, as it will
+    // avoid storing in memory addresses that it knows it can't connect to.
+    // The condition below is a hint, and false-positives or false-negatives are not fundamentally
+    // an issue.
+    if ((typeof isSecureContext === 'boolean' && isSecureContext) && typeof location !== undefined) {
+        const loc = location.toString();
+        if (loc.indexOf('localhost') !== -1 && loc.indexOf('127.0.0.1') !== -1 && loc.indexOf('::1') !== -1) {
+            options.forbidNonLocalWs = true;
+        }
+    }
     return (0, client_js_1.start)(options, options.bytecode, {
         performanceNow: () => {
             return performance.now();
@@ -142,12 +155,14 @@ function connect(config) {
                 connection = null;
             },
             send: (data) => {
-                connection.send(data);
                 if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
                     bufferedAmountCheck.nextTimeout = 10;
                     setTimeout(checkBufferedAmount, 10);
                 }
-                bufferedAmountCheck.quenedUnreportedBytes += data.length;
+                for (const buffer of data) {
+                    bufferedAmountCheck.quenedUnreportedBytes += buffer.length;
+                }
+                connection.send(new Blob(data));
             },
             closeSend: () => { throw new Error('Wrong connection type'); },
             openOutSubstream: () => { throw new Error('Wrong connection type'); }
@@ -155,56 +170,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 +223,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 +254,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 +293,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 +307,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 +342,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 +403,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,20 +421,22 @@ 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);
-                channel.channel.send(data);
-                channel.bufferedBytes += data.length;
+                const channel = state.dataChannels.get(streamId);
+                for (const buffer of data) {
+                    channel.bufferedBytes += buffer.length;
+                }
+                channel.channel.send(new Blob(data));
             },
             closeSend: () => { throw new Error('Wrong connection type'); },
             openOutSubstream: () => {
@@ -412,7 +444,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');
             }
         };
     }

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

@@ -105,12 +105,14 @@ function connect(config) {
                 // we thus absorb any exception thrown here.
                 // See also <https://github.com/paritytech/smoldot/issues/2937>.
                 try {
-                    socket.send(data);
                     if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
                         bufferedAmountCheck.nextTimeout = 10;
                         setTimeout(checkBufferedAmount, 10);
                     }
-                    bufferedAmountCheck.quenedUnreportedBytes += data.length;
+                    for (const buffer of data) {
+                        bufferedAmountCheck.quenedUnreportedBytes += buffer.length;
+                    }
+                    socket.send(new Blob(data));
                 }
                 catch (_error) { }
             },
@@ -172,31 +174,35 @@ function connect(config) {
                 socket.inner.then((connec) => connec.close());
             },
             send: (data) => {
-                let dataCopy = Uint8Array.from(data); // Deep copy of the data
+                let dataCopy = data.map((buf) => Uint8Array.from(buf)); // Deep copy of the data
                 socket.inner = socket.inner.then((c) => __awaiter(this, void 0, void 0, function* () {
-                    while (dataCopy.length > 0) {
-                        if (socket.destroyed || c === null)
-                            return c;
-                        let outcome;
-                        try {
-                            outcome = yield c.write(dataCopy);
-                            config.onWritableBytes(dataCopy.length);
-                        }
-                        catch (error) {
-                            // The type of `error` is unclear, but we assume that it implements `Error`
-                            outcome = error.toString();
-                        }
-                        if (typeof outcome !== 'number') {
-                            // The socket is reported closed, but `socket.destroyed` is still
-                            // `false` (see check above). As such, we must inform the inner layers.
-                            socket.destroyed = true;
-                            config.onConnectionReset(outcome);
-                            return c;
+                    for (let buffer of dataCopy) {
+                        while (buffer.length > 0) {
+                            if (socket.destroyed || c === null)
+                                return c;
+                            let outcome;
+                            try {
+                                outcome = yield c.write(buffer);
+                                config.onWritableBytes(buffer.length);
+                            }
+                            catch (error) {
+                                // The type of `error` is unclear, but we assume that it
+                                // implements `Error`
+                                outcome = error.toString();
+                            }
+                            if (typeof outcome !== 'number') {
+                                // The socket is reported closed, but `socket.destroyed` is still
+                                // `false` (see check above). As such, we must inform the
+                                // inner layers.
+                                socket.destroyed = true;
+                                config.onConnectionReset(outcome);
+                                return c;
+                            }
+                            // Note that, contrary to `read`, it is possible for `outcome` to be 0.
+                            // This happen if the write had to be interrupted, and the only thing
+                            // we have to do is try writing again.
+                            buffer = buffer.slice(outcome);
                         }
-                        // Note that, contrary to `read`, it is possible for `outcome` to be 0.
-                        // This happen if the write had to be interrupted, and the only thing
-                        // we have to do is try writing again.
-                        dataCopy = dataCopy.slice(outcome);
                     }
                     return c;
                 }));

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

@@ -106,12 +106,14 @@ function connect(config) {
                 socket.close();
             },
             send: (data) => {
-                socket.send(data);
                 if (bufferedAmountCheck.quenedUnreportedBytes == 0) {
                     bufferedAmountCheck.nextTimeout = 10;
                     setTimeout(checkBufferedAmount, 10);
                 }
-                bufferedAmountCheck.quenedUnreportedBytes += data.length;
+                for (const buffer of data) {
+                    socket.send(buffer);
+                    bufferedAmountCheck.quenedUnreportedBytes += buffer.length;
+                }
             },
             closeSend: () => { throw new Error('Wrong connection type'); },
             openOutSubstream: () => { throw new Error('Wrong connection type'); }
@@ -158,17 +160,19 @@ function connect(config) {
                 socket.destroy();
             },
             send: (data) => {
-                const dataLen = data.length;
-                const allWritten = socket.write(data);
-                if (allWritten) {
-                    setImmediate(() => {
-                        if (!socket.writable)
-                            return;
-                        config.onWritableBytes(dataLen);
-                    });
-                }
-                else {
-                    drainingBytes.num += dataLen;
+                for (const buffer of data) {
+                    const bufferLen = buffer.length;
+                    const allWritten = socket.write(buffer);
+                    if (allWritten) {
+                        setImmediate(() => {
+                            if (!socket.writable)
+                                return;
+                            config.onWritableBytes(bufferLen);
+                        });
+                    }
+                    else {
+                        drainingBytes.num += bufferLen;
+                    }
                 }
             },
             closeSend: () => {