werift 0.22.8 → 0.23.0

package/lib/sctp/src/sctp.d.ts

@@ -21,6 +21,8 @@ export declare class SCTP {
     started: boolean;
     state: SCTPConnectionState;
     isServer: boolean;
+    private isStopping;
+    private isClosed;
     private hmacKey;
     private localPartialReliability;
     private localPort;
@@ -30,6 +32,8 @@ export declare class SCTP {
     private remotePort?;
     private remoteVerificationTag;
     private advertisedRwnd;
+    private peerAdvertisedRwnd;
+    private get peerRwnd();
     private inboundStreams;
     _inboundStreamsCount: number;
     _inboundStreamsMax: number;
@@ -37,6 +41,9 @@ export declare class SCTP {
     private sackDuplicates;
     private sackMisOrdered;
     private sackNeeded;
+    private sackPacketCount;
+    private sackHasNewDataInPacket;
+    private sackImmediate;
     private sackTimeout;
     private cwnd;
     private fastRecoveryExit?;
@@ -52,6 +59,8 @@ export declare class SCTP {
     private advancedPeerAckTsn;
     private partialBytesAcked;
     private sentQueue;
+    private transmitting;
+    private transmitRequested;
     /**初期TSNと同じ値に初期化される単調に増加する数です. これは、新しいre-configuration requestパラメーターを送信するたびに1ずつ増加します */
     reconfigRequestSeq: number;
     /**このフィールドは、incoming要求のre-configuration requestシーケンス番号を保持します. 他の場合では、次に予想されるre-configuration requestシーケンス番号から1を引いた値が保持されます */
@@ -74,12 +83,16 @@ export declare class SCTP {
     /**Re-configuration Timer */
     private timerReconfigHandle?;
     private timerReconfigFailures;
+    private timerHeartbeatHandle?;
+    private heartbeatInterval;
     private ssthresh?;
     constructor(transport: Transport, port?: number);
+    private get isStopped();
     get maxChannels(): number | undefined;
     static client(transport: Transport, port?: number): SCTP;
     static server(transport: Transport, port?: number): SCTP;
     private handleData;
+    private scheduleSack;
     private sendSack;
     private receiveChunk;
     private getExtensions;
@@ -97,6 +110,7 @@ export declare class SCTP {
         ordered?: boolean;
     }) => Promise<void>;
     private transmit;
+    private transmitOnce;
     transmitReconfigRequest(): Promise<void>;
     sendReconfigParam(param: StreamParam): Promise<void>;
     private sendResetRequest;
@@ -119,6 +133,11 @@ export declare class SCTP {
     private timerReconfigHandleStart;
     private timerReconfigHandleExpired;
     private timerReconfigCancel;
+    private heartbeatStart;
+    private heartbeatRestart;
+    private heartbeatCancel;
+    private timerHeartbeatExpired;
+    setHeartbeatInterval(interval: number): void;
     private updateAdvancedPeerAckPoint;
     private maybeAbandon;
     static getCapabilities(): RTCSctpCapabilities;

package/lib/sctp/src/sctp.js

@@ -23,10 +23,16 @@ const SCTP_MAX_ASSOCIATION_RETRANS = 10;
 const SCTP_MAX_INIT_RETRANS = 8;
 const SCTP_RTO_ALPHA = 1 / 8;
 const SCTP_RTO_BETA = 1 / 4;
+// RFC 9260 RTO.Initial/RTO.Min/RTO.Max defaults and bounds are in seconds.
 const SCTP_RTO_INITIAL = 3;
 const SCTP_RTO_MIN = 1;
 const SCTP_RTO_MAX = 60;
 const SCTP_TSN_MODULO = 2 ** 32;
+// RFC 9260 delayed ACK guidance: send SACK within 200ms at the latest.
+// Use a small default delay to keep request/response latency low while still delaying ACKs.
+const SCTP_SACK_DELAY_MS = 200;
+// RFC 9260 HB.interval recommended default is 30 seconds.
+const SCTP_HEARTBEAT_INTERVAL = 30;
 const RECONFIG_MAX_STREAMS = 135;
 // # parameters
 const SCTP_STATE_COOKIE = 0x0007;
@@ -39,6 +45,10 @@ const SCTPConnectionStates = [
     "connecting",
 ];
 class SCTP {
+    get peerRwnd() {
+        // RFC 9260 §6.2.1(D-ii): available receiver window = a_rwnd - outstanding DATA.
+        return Math.max(0, this.peerAdvertisedRwnd - this.flightSize);
+    }
     constructor(transport, port = 5000) {
         Object.defineProperty(this, "transport", {
             enumerable: true,
@@ -107,6 +117,18 @@ class SCTP {
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "isStopping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "isClosed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "hmacKey", {
             enumerable: true,
             configurable: true,
@@ -162,6 +184,12 @@ class SCTP {
             writable: true,
             value: 1024 * 1024
         }); // Receiver Window
+        Object.defineProperty(this, "peerAdvertisedRwnd", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: this.advertisedRwnd
+        });
         Object.defineProperty(this, "inboundStreams", {
             enumerable: true,
             configurable: true,
@@ -204,6 +232,24 @@ class SCTP {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "sackPacketCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "sackHasNewDataInPacket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "sackImmediate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "sackTimeout", {
             enumerable: true,
             configurable: true,
@@ -290,6 +336,18 @@ class SCTP {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "transmitting", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "transmitRequested", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         // # reconfiguration
         /**初期TSNと同じ値に初期化される単調に増加する数です. これは、新しいre-configuration requestパラメーターを送信するたびに1ずつ増加します */
         Object.defineProperty(this, "reconfigRequestSeq", {
@@ -395,6 +453,18 @@ class SCTP {
             writable: true,
             value: 0
         });
+        Object.defineProperty(this, "timerHeartbeatHandle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "heartbeatInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: SCTP_HEARTBEAT_INTERVAL
+        });
         // etc
         Object.defineProperty(this, "ssthresh", {
             enumerable: true,
@@ -441,17 +511,9 @@ class SCTP {
                 if (ordered) {
                     this.outboundStreamSeq[streamId] = (0, common_1.uint16Add)(streamSeqNum, 1);
                 }
-                if (!this.timer3Handle) {
-                    await this.transmit();
-                }
-                else {
-                    if (this.outboundQueue.length) {
-                        await this.flush.asPromise();
-                    }
-                    else {
-                        // unreachable?
-                        await new Promise((r) => setImmediate(r));
-                    }
+                await this.transmit();
+                while (this.outboundQueue.length) {
+                    await this.flush.asPromise();
                 }
             }
         });
@@ -460,6 +522,8 @@ class SCTP {
             configurable: true,
             writable: true,
             value: () => {
+                if (this.isStopped)
+                    return;
                 this.timer1Failures++;
                 this.timer1Handle = undefined;
                 if (this.timer1Failures > SCTP_MAX_INIT_RETRANS) {
@@ -467,10 +531,14 @@ class SCTP {
                 }
                 else {
                     setImmediate(() => {
+                        if (this.isStopped)
+                            return;
                         this.sendChunk(this.timer1Chunk).catch((err) => {
                             log("send timer1 chunk failed", err.message);
                         });
                     });
+                    if (this.isStopped)
+                        return;
                     this.timer1Handle = setTimeout(this.timer1Expired, this.rto * 1000);
                 }
             }
@@ -480,6 +548,8 @@ class SCTP {
             configurable: true,
             writable: true,
             value: () => {
+                if (this.isStopped)
+                    return;
                 this.timer2Failures++;
                 this.timer2Handle = undefined;
                 if (this.timer2Failures > SCTP_MAX_ASSOCIATION_RETRANS) {
@@ -487,10 +557,14 @@ class SCTP {
                 }
                 else {
                     setImmediate(() => {
+                        if (this.isStopped)
+                            return;
                         this.sendChunk(this.timer2Chunk).catch((err) => {
                             log("send timer2Chunk failed", err.message);
                         });
                     });
+                    if (this.isStopped)
+                        return;
                     this.timer2Handle = setTimeout(this.timer2Expired, this.rto * 1000);
                 }
             }
@@ -500,6 +574,8 @@ class SCTP {
             configurable: true,
             writable: true,
             value: () => {
+                if (this.isStopped)
+                    return;
                 this.timer3Handle = undefined;
                 // # mark retransmit or abandoned chunks
                 this.sentQueue.forEach((chunk) => {
@@ -522,6 +598,8 @@ class SCTP {
             configurable: true,
             writable: true,
             value: async () => {
+                if (this.isStopped)
+                    return;
                 this.timerReconfigFailures++;
                 // back off
                 this.rto = Math.ceil(this.rto * 1.5);
@@ -533,15 +611,41 @@ class SCTP {
                 else if (this.reconfigRequest) {
                     log("timerReconfigHandleExpired", this.timerReconfigFailures, this.rto);
                     await this.sendReconfigParam(this.reconfigRequest);
+                    if (this.isStopped)
+                        return;
                     this.timerReconfigHandle = setTimeout(this.timerReconfigHandleExpired, this.rto * 1000);
                 }
             }
         });
+        Object.defineProperty(this, "timerHeartbeatExpired", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async () => {
+                this.timerHeartbeatHandle = undefined;
+                if (this.associationState !== const_1.SCTP_STATE.ESTABLISHED)
+                    return;
+                if (this.flightSize === 0 && this.outboundQueue.length === 0) {
+                    const heartbeat = new chunk_1.HeartbeatChunk();
+                    heartbeat.params.push([
+                        1,
+                        Buffer.from(jspack_1.jspack.Pack("!L", [Math.floor(Date.now() / 1000)])),
+                    ]);
+                    await this.sendChunk(heartbeat).catch((err) => {
+                        log("send heartbeat failed", err.message);
+                    });
+                }
+                this.heartbeatStart();
+            }
+        });
         this.localPort = this.port;
         this.transport.onData = (buf) => {
             this.handleData(buf);
         };
     }
+    get isStopped() {
+        return this.isStopping || this.isClosed;
+    }
     get maxChannels() {
         if (this._inboundStreamsCount > 0) {
             return Math.min(this._inboundStreamsCount, this._outboundStreamsCount);
@@ -560,6 +664,8 @@ class SCTP {
     }
     // call from dtls transport
     async handleData(data) {
+        if (this.isStopped)
+            return;
         let expectedTag;
         const [, , verificationTag, chunks] = (0, chunk_1.parsePacket)(data);
         const initChunk = chunks.filter((v) => v.type === chunk_1.InitChunk.type).length;
@@ -575,18 +681,47 @@ class SCTP {
         if (verificationTag !== expectedTag) {
             return;
         }
+        this.sackHasNewDataInPacket = false;
         for (const chunk of chunks) {
             await this.receiveChunk(chunk);
         }
         if (this.sackNeeded) {
+            // RFC 9260 delayed ACK guidance is per packet ("every second packet").
+            if (this.sackHasNewDataInPacket) {
+                this.sackPacketCount++;
+            }
+            if (this.sackPacketCount >= 2) {
+                this.sackImmediate = true;
+            }
+            await this.scheduleSack();
+        }
+    }
+    async scheduleSack() {
+        if (this.isStopped)
+            return;
+        if (!this.sackNeeded)
+            return;
+        if (this.sackImmediate) {
+            if (this.sackTimeout) {
+                clearTimeout(this.sackTimeout);
+                this.sackTimeout = undefined;
+            }
             await this.sendSack();
+            return;
         }
+        if (this.sackTimeout)
+            return;
+        // RFC 9260 delayed ACK path: defer SACK, but never beyond 200ms.
+        this.sackTimeout = setTimeout(() => {
+            this.sackTimeout = undefined;
+            this.sendSack().catch((err) => {
+                log("send delayed sack failed", err.message);
+            });
+        }, SCTP_SACK_DELAY_MS);
     }
     async sendSack() {
-        if (this.sackTimeout)
+        if (this.isStopped)
             return;
-        await new Promise((r) => (this.sackTimeout = setImmediate(r)));
-        this.sackTimeout = undefined;
         if (!this.sackNeeded)
             return;
         const gaps = [];
@@ -611,6 +746,8 @@ class SCTP {
         });
         this.sackDuplicates = [];
         this.sackNeeded = false;
+        this.sackPacketCount = 0;
+        this.sackImmediate = false;
     }
     async receiveChunk(chunk) {
         switch (chunk.type) {
@@ -629,6 +766,7 @@ class SCTP {
                     this.reconfigResponseSeq = tsnMinusOne(init.initialTsn);
                     this.remoteVerificationTag = init.initiateTag;
                     this.ssthresh = init.advertisedRwnd;
+                    this.peerAdvertisedRwnd = init.advertisedRwnd;
                     this.getExtensions(init.params);
                     this._inboundStreamsCount = Math.min(init.outboundStreams, this._inboundStreamsMax);
                     this._outboundStreamsCount = Math.min(this._outboundStreamsCount, init.inboundStreams);
@@ -662,6 +800,7 @@ class SCTP {
                     this.reconfigResponseSeq = tsnMinusOne(initAck.initialTsn);
                     this.remoteVerificationTag = initAck.initiateTag;
                     this.ssthresh = initAck.advertisedRwnd;
+                    this.peerAdvertisedRwnd = initAck.advertisedRwnd;
                     this.getExtensions(initAck.params);
                     this._inboundStreamsCount = Math.min(initAck.outboundStreams, this._inboundStreamsMax);
                     this._outboundStreamsCount = Math.min(this._outboundStreamsCount, initAck.inboundStreams);
@@ -862,8 +1001,21 @@ class SCTP {
     }
     receiveDataChunk(chunk) {
         this.sackNeeded = true;
-        if (this.markReceived(chunk.tsn))
+        if (this.markReceived(chunk.tsn)) {
+            this.sackImmediate = true;
             return;
+        }
+        this.sackHasNewDataInPacket = true;
+        // RFC 9260 delayed ACK is optional; prefer immediate DATA ACK to keep ACK-clock responsive.
+        this.sackImmediate = true;
+        if ((chunk.flags & SCTP_DATA_LAST_FRAG) === 0) {
+            // Keep fragmented-message feedback prompt to avoid long tail-loss recovery.
+            this.sackImmediate = true;
+        }
+        if (this.sackMisOrdered.size > 0) {
+            // RFC 9260 permits immediate SACK on gap/loss indicators.
+            this.sackImmediate = true;
+        }
         const inboundStream = this.getInboundStream(chunk.streamId);
         inboundStream.addChunk(chunk);
         this.advertisedRwnd -= chunk.userData.length;
@@ -972,12 +1124,15 @@ class SCTP {
         else if (done > 0) {
             this.timer3Restart();
         }
+        // RFC 9260 §6.2.1(D-ii): keep latest peer a_rwnd; available window is derived via flightSize.
+        this.peerAdvertisedRwnd = chunk.advertisedRwnd;
         this.updateAdvancedPeerAckPoint();
         await this.onSackReceived();
         await this.transmit();
     }
     receiveForwardTsnChunk(chunk) {
         this.sackNeeded = true;
+        this.sackImmediate = true;
         if ((0, common_1.uint32Gte)(this.lastReceivedTsn, chunk.cumulativeTsn)) {
             return;
         }
@@ -1053,6 +1208,26 @@ class SCTP {
         return false;
     }
     async transmit() {
+        if (this.isStopped)
+            return;
+        if (this.transmitting) {
+            this.transmitRequested = true;
+            return;
+        }
+        this.transmitting = true;
+        try {
+            do {
+                this.transmitRequested = false;
+                await this.transmitOnce();
+            } while (this.transmitRequested);
+        }
+        finally {
+            this.transmitting = false;
+        }
+    }
+    async transmitOnce() {
+        if (this.isStopped)
+            return;
         // """
         // Transmit outbound data.
         // """
@@ -1077,7 +1252,7 @@ class SCTP {
                     this.fastRecoveryTransmit = false;
                 }
                 else if (this.flightSize >= cwnd) {
-                    return;
+                    break;
                 }
                 this.flightSizeIncrease(dataChunk);
                 dataChunk.misses = 0;
@@ -1092,11 +1267,17 @@ class SCTP {
             }
             retransmitEarliest = false;
         }
-        // for performance todo fix
-        while (this.outboundQueue.length > 0) {
+        // Drain queued outbound DATA; retransmission pacing is controlled by RTO/T3.
+        while (this.outboundQueue.length > 0 &&
+            this.flightSize < cwnd &&
+            this.peerRwnd > 0) {
             const chunk = this.outboundQueue.shift();
             if (!chunk)
-                return;
+                break;
+            if (chunk.bookSize > this.peerRwnd && this.flightSize > 0) {
+                this.outboundQueue.unshift(chunk);
+                break;
+            }
             this.sentQueue.push(chunk);
             this.flightSizeIncrease(chunk);
             // # update counters
@@ -1109,8 +1290,10 @@ class SCTP {
                 this.timer3Start();
             }
         }
-        // Resetting the queue to empty array mitigates this.
-        this.outboundQueue = [];
+        if (!this.outboundQueue.length) {
+            // Resetting the queue to empty array mitigates this.
+            this.outboundQueue = [];
+        }
         this.flush.execute();
     }
     async transmitReconfigRequest() {
@@ -1185,14 +1368,19 @@ class SCTP {
     }
     /**t3 is wait for data sack */
     timer3Start() {
+        if (this.isStopped)
+            return;
         if (this.timer3Handle)
             throw new Error();
+        // RFC 9260 T3-rtx runs on current RTO; rto is stored in seconds.
         this.timer3Handle = setTimeout(this.timer3Expired, this.rto * 1000);
     }
     timer3Restart() {
+        if (this.isStopped)
+            return;
         this.timer3Cancel();
-        // for performance
-        this.timer3Handle = setTimeout(this.timer3Expired, this.rto);
+        // RFC 9260 requires restarting T3-rtx with current RTO (seconds -> JS ms).
+        this.timer3Handle = setTimeout(this.timer3Expired, this.rto * 1000);
     }
     timer3Cancel() {
         if (this.timer3Handle) {
@@ -1202,6 +1390,8 @@ class SCTP {
     }
     /**Re-configuration Timer */
     timerReconfigHandleStart() {
+        if (this.isStopped)
+            return;
         if (this.timerReconfigHandle)
             return;
         log("timerReconfigHandleStart", { rto: this.rto });
@@ -1217,6 +1407,31 @@ class SCTP {
             this.timerReconfigFailures = 0;
         }
     }
+    heartbeatStart() {
+        if (this.timerHeartbeatHandle ||
+            this.associationState !== const_1.SCTP_STATE.ESTABLISHED) {
+            return;
+        }
+        // RFC 9260 heartbeat timer is based on RTO + HB.interval for idle paths.
+        this.timerHeartbeatHandle = setTimeout(this.timerHeartbeatExpired, (this.rto + this.heartbeatInterval) * 1000);
+    }
+    heartbeatRestart() {
+        this.heartbeatCancel();
+        this.heartbeatStart();
+    }
+    heartbeatCancel() {
+        if (this.timerHeartbeatHandle) {
+            clearTimeout(this.timerHeartbeatHandle);
+            this.timerHeartbeatHandle = undefined;
+        }
+    }
+    setHeartbeatInterval(interval) {
+        if (interval <= 0) {
+            throw new Error("heartbeat interval must be > 0");
+        }
+        this.heartbeatInterval = interval;
+        this.heartbeatRestart();
+    }
     updateAdvancedPeerAckPoint() {
         if ((0, common_1.uint32Gt)(this.lastSackedTsn, this.advancedPeerAckTsn)) {
             this.advancedPeerAckTsn = this.lastSackedTsn;
@@ -1330,13 +1545,22 @@ class SCTP {
             this.associationState = state;
         }
         if (state === const_1.SCTP_STATE.ESTABLISHED) {
+            this.isStopping = false;
+            this.isClosed = false;
             this.setConnectionState("connected");
+            this.heartbeatStart();
         }
         else if (state === const_1.SCTP_STATE.CLOSED) {
+            this.isClosed = true;
             this.timer1Cancel();
             this.timer2Cancel();
             this.timer3Cancel();
             this.timerReconfigCancel();
+            this.heartbeatCancel();
+            if (this.sackTimeout) {
+                clearTimeout(this.sackTimeout);
+                this.sackTimeout = undefined;
+            }
             this.setConnectionState("closed");
             this.removeAllListeners();
         }
@@ -1347,6 +1571,16 @@ class SCTP {
         this.stateChanged[state].execute();
     }
     async stop() {
+        if (this.isStopped) {
+            this.setState(const_1.SCTP_STATE.CLOSED);
+            return;
+        }
+        this.isStopping = true;
+        this.transport.onData = undefined;
+        if (this.sackTimeout) {
+            clearTimeout(this.sackTimeout);
+            this.sackTimeout = undefined;
+        }
         if (this.associationState !== const_1.SCTP_STATE.CLOSED) {
             await this.abort();
         }
@@ -1355,6 +1589,8 @@ class SCTP {
         clearTimeout(this.timer2Handle);
         clearTimeout(this.timer3Handle);
         clearTimeout(this.timerReconfigHandle);
+        clearTimeout(this.timerHeartbeatHandle);
+        clearTimeout(this.sackTimeout);
     }
     async abort() {
         const abort = new chunk_1.AbortChunk();