werift 0.14.3 → 0.14.4-debug0

package/lib/sctp/src/sctp.js

@@ -96,7 +96,7 @@ class SCTP {
         this.timer1Failures = 0;
         this.timer2Failures = 0;
         this.timerReconfigFailures = 0;
-        this.send = async (streamId, ppId, userData, expiry = undefined, maxRetransmits = undefined, ordered = true) => {
+        this.send = async (streamId, ppId, userData, { expiry, maxRetransmits, ordered, } = { expiry: undefined, maxRetransmits: undefined, ordered: true }) => {
             const streamSeqNum = ordered ? this.outboundStreamSeq[streamId] || 0 : 0;
             const fragments = Math.ceil(userData.length / USERDATA_MAX_LENGTH);
             let pos = 0;
@@ -145,7 +145,11 @@ class SCTP {
                 this.setState(const_1.SCTP_STATE.CLOSED);
             }
             else {
-                setImmediate(() => this.sendChunk(this.timer1Chunk));
+                setImmediate(() => {
+                    this.sendChunk(this.timer1Chunk).catch((err) => {
+                        log("send timer1 chunk failed", err.message);
+                    });
+                });
                 this.timer1Handle = setTimeout(this.timer1Expired, this.rto * 1000);
             }
         };
@@ -156,7 +160,11 @@ class SCTP {
                 this.setState(const_1.SCTP_STATE.CLOSED);
             }
             else {
-                setImmediate(() => this.sendChunk(this.timer2Chunk));
+                setImmediate(() => {
+                    this.sendChunk(this.timer2Chunk).catch((err) => {
+                        log("send timer2Chunk failed", err.message);
+                    });
+                });
                 this.timer2Handle = setTimeout(this.timer2Expired, this.rto * 1000);
             }
         };
@@ -252,18 +260,24 @@ class SCTP {
         sack.advertisedRwnd = Math.max(0, this.advertisedRwnd);
         sack.duplicates = [...this.sackDuplicates];
         sack.gaps = gaps;
-        await this.sendChunk(sack);
+        await this.sendChunk(sack).catch((err) => {
+            log("send sack failed", err.message);
+        });
         this.sackDuplicates = [];
         this.sackNeeded = false;
     }
     async receiveChunk(chunk) {
         switch (chunk.type) {
             case chunk_1.DataChunk.type:
-                this.receiveDataChunk(chunk);
+                {
+                    this.receiveDataChunk(chunk);
+                }
                 break;
             case chunk_1.InitChunk.type:
-                const init = chunk;
-                if (this.isServer) {
+                {
+                    if (!this.isServer)
+                        return;
+                    const init = chunk;
                     log("receive init", init);
                     this.lastReceivedTsn = tsnMinusOne(init.initialTsn);
                     this.reconfigResponseSeq = tsnMinusOne(init.initialTsn);
@@ -287,11 +301,15 @@ class SCTP {
                     ]);
                     ack.params.push([SCTP_STATE_COOKIE, cookie]);
                     log("send initAck", ack);
-                    await this.sendChunk(ack);
+                    await this.sendChunk(ack).catch((err) => {
+                        log("send initAck failed", err.message);
+                    });
                 }
                 break;
             case chunk_1.InitAckChunk.type:
-                if (this.associationState === const_1.SCTP_STATE.COOKIE_WAIT) {
+                {
+                    if (this.associationState != const_1.SCTP_STATE.COOKIE_WAIT)
+                        return;
                     const initAck = chunk;
                     this.timer1Cancel();
                     this.lastReceivedTsn = tsnMinusOne(initAck.initialTsn);
@@ -308,42 +326,58 @@ class SCTP {
                             break;
                         }
                     }
-                    await this.sendChunk(echo);
+                    await this.sendChunk(echo).catch((err) => {
+                        log("send echo failed", err.message);
+                    });
                     this.timer1Start(echo);
                     this.setState(const_1.SCTP_STATE.COOKIE_ECHOED);
                 }
                 break;
             case chunk_1.SackChunk.type:
-                await this.receiveSackChunk(chunk);
+                {
+                    await this.receiveSackChunk(chunk);
+                }
                 break;
             case chunk_1.HeartbeatChunk.type:
-                const ack = new chunk_1.HeartbeatAckChunk();
-                ack.params = chunk.params;
-                await this.sendChunk(ack);
+                {
+                    const ack = new chunk_1.HeartbeatAckChunk();
+                    ack.params = chunk.params;
+                    await this.sendChunk(ack).catch((err) => {
+                        log("send heartbeat ack failed", err.message);
+                    });
+                }
                 break;
             case chunk_1.AbortChunk.type:
-                this.setState(const_1.SCTP_STATE.CLOSED);
+                {
+                    this.setState(const_1.SCTP_STATE.CLOSED);
+                }
                 break;
             case chunk_1.ShutdownChunk.type:
                 {
                     this.timer2Cancel();
                     this.setState(const_1.SCTP_STATE.SHUTDOWN_RECEIVED);
                     const ack = new chunk_1.ShutdownAckChunk();
-                    await this.sendChunk(ack);
+                    await this.sendChunk(ack).catch((err) => {
+                        log("send shutdown ack failed", err.message);
+                    });
                     this.t2Start(ack);
                     this.setState(const_1.SCTP_STATE.SHUTDOWN_SENT);
                 }
                 break;
             case chunk_1.ErrorChunk.type:
-                // 3.3.10.  Operation Error (ERROR) (9)
-                // An Operation Error is not considered fatal in and of itself, but may be
-                // used with an ABORT chunk to report a fatal condition.  It has the
-                // following parameters:
-                log("ErrorChunk", chunk.descriptions);
+                {
+                    // 3.3.10.  Operation Error (ERROR) (9)
+                    // An Operation Error is not considered fatal in and of itself, but may be
+                    // used with an ABORT chunk to report a fatal condition.  It has the
+                    // following parameters:
+                    log("ErrorChunk", chunk.descriptions);
+                }
                 break;
             case chunk_1.CookieEchoChunk.type:
-                const data = chunk;
-                if (this.isServer) {
+                {
+                    if (!this.isServer)
+                        return;
+                    const data = chunk;
                     const cookie = data.body;
                     const digest = (0, crypto_1.createHmac)("sha1", this.hmacKey)
                         .update(cookie.slice(0, 4))
@@ -361,29 +395,39 @@ class SCTP {
                             chunk_1.ErrorChunk.CODE.StaleCookieError,
                             Buffer.concat([...Array(8)].map(() => Buffer.from("\x00"))),
                         ]);
-                        await this.sendChunk(error);
+                        await this.sendChunk(error).catch((err) => {
+                            log("send errorChunk failed", err.message);
+                        });
                         return;
                     }
                     const ack = new chunk_1.CookieAckChunk();
-                    await this.sendChunk(ack);
+                    await this.sendChunk(ack).catch((err) => {
+                        log("send cookieAck failed", err.message);
+                    });
                     this.setState(const_1.SCTP_STATE.ESTABLISHED);
                 }
                 break;
             case chunk_1.CookieAckChunk.type:
-                if (this.associationState === const_1.SCTP_STATE.COOKIE_ECHOED) {
+                {
+                    if (this.associationState != const_1.SCTP_STATE.COOKIE_ECHOED)
+                        return;
                     this.timer1Cancel();
                     this.setState(const_1.SCTP_STATE.ESTABLISHED);
                 }
                 break;
             case chunk_1.ShutdownCompleteChunk.type:
-                if (this.associationState === const_1.SCTP_STATE.SHUTDOWN_ACK_SENT) {
+                {
+                    if (this.associationState != const_1.SCTP_STATE.SHUTDOWN_ACK_SENT)
+                        return;
                     this.timer2Cancel();
                     this.setState(const_1.SCTP_STATE.CLOSED);
                 }
                 break;
             // extensions
             case chunk_1.ReconfigChunk.type:
-                if (this.associationState === const_1.SCTP_STATE.ESTABLISHED) {
+                {
+                    if (this.associationState != const_1.SCTP_STATE.ESTABLISHED)
+                        return;
                     const reconfig = chunk;
                     for (const [type, body] of reconfig.params) {
                         const target = param_1.RECONFIG_PARAM_BY_TYPES[type];
@@ -394,7 +438,9 @@ class SCTP {
                 }
                 break;
             case chunk_1.ForwardTsnChunk.type:
-                this.receiveForwardTsnChunk(chunk);
+                {
+                    this.receiveForwardTsnChunk(chunk);
+                }
                 break;
         }
     }
@@ -654,7 +700,9 @@ class SCTP {
         // """
         // # send FORWARD TSN
         if (this.forwardTsnChunk) {
-            await this.sendChunk(this.forwardTsnChunk);
+            await this.sendChunk(this.forwardTsnChunk).catch((err) => {
+                log("send forwardTsn failed", err.message);
+            });
             this.forwardTsnChunk = undefined;
             if (!this.timer3Handle) {
                 this.timer3Start();
@@ -677,7 +725,9 @@ class SCTP {
                 dataChunk.misses = 0;
                 dataChunk.retransmit = false;
                 dataChunk.sentCount++;
-                await this.sendChunk(dataChunk);
+                await this.sendChunk(dataChunk).catch((err) => {
+                    log("send data failed", err.message);
+                });
                 if (retransmitEarliest) {
                     this.timer3Restart();
                 }
@@ -694,7 +744,9 @@ class SCTP {
             // # update counters
             chunk.sentCount++;
             chunk.sentTime = Date.now() / 1000;
-            await this.sendChunk(chunk);
+            await this.sendChunk(chunk).catch((err) => {
+                log("send data outboundQueue failed", err.message);
+            });
             if (!this.timer3Handle) {
                 this.timer3Start();
             }
@@ -717,7 +769,9 @@ class SCTP {
         log("sendReconfigParam", param);
         const chunk = new chunk_1.ReconfigChunk();
         chunk.params.push([param.type, param.bytes]);
-        await this.sendChunk(chunk);
+        await this.sendChunk(chunk).catch((err) => {
+            log("send reconfig failed", err.message);
+        });
     }
     // https://github.com/pion/sctp/pull/44/files
     async sendResetRequest(streamId) {
@@ -874,10 +928,15 @@ class SCTP {
         init.initialTsn = this.localTsn;
         this.setExtensions(init.params);
         log("send init", init);
-        await this.sendChunk(init);
-        // # start T1 timer and enter COOKIE-WAIT state
-        this.timer1Start(init);
-        this.setState(const_1.SCTP_STATE.COOKIE_WAIT);
+        try {
+            await this.sendChunk(init);
+            // # start T1 timer and enter COOKIE-WAIT state
+            this.timer1Start(init);
+            this.setState(const_1.SCTP_STATE.COOKIE_WAIT);
+        }
+        catch (error) {
+            log("send init failed", error.message);
+        }
     }
     setExtensions(params) {
         const extensions = [];
@@ -889,10 +948,11 @@ class SCTP {
         params.push([SCTP_SUPPORTED_CHUNK_EXT, Buffer.from(extensions)]);
     }
     async sendChunk(chunk) {
-        if (this.remotePort === undefined)
-            throw new Error("invalid remote port");
         if (this.state === "closed")
             return;
+        if (this.remotePort === undefined) {
+            throw new Error("invalid remote port");
+        }
         const packet = (0, chunk_1.serializePacket)(this.localPort, this.remotePort, this.remoteVerificationTag, chunk);
         await this.transport.send(packet);
     }
@@ -913,6 +973,7 @@ class SCTP {
     }
     setConnectionState(state) {
         this.state = state;
+        log("setConnectionState", state);
         this.stateChanged[state].execute();
     }
     async stop() {
@@ -926,7 +987,9 @@ class SCTP {
     }
     async abort() {
         const abort = new chunk_1.AbortChunk();
-        await this.sendChunk(abort);
+        await this.sendChunk(abort).catch((err) => {
+            log("send abort failed", err.message);
+        });
     }
     removeAllListeners() {
         Object.values(this.stateChanged).forEach((v) => v.allUnsubscribe());