werift 0.24.0 → 0.24.2

package/lib/ice/src/ice.js

@@ -32,16 +32,11 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connection = void 0;
 const crypto_1 = require("crypto");
 const net_1 = require("net");
-const Int64 = __importStar(require("int64-buffer"));
 const timers = __importStar(require("node:timers/promises"));
-const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
 const common_1 = require("./imports/common");
 const candidate_1 = require("./candidate");
 const lookup_1 = require("./dns/lookup");
@@ -150,7 +145,7 @@ class Connection {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: BigInt(new Int64.Uint64BE((0, crypto_1.randomBytes)(64)).toString())
+            value: (0, crypto_1.randomBytes)(8).readBigUInt64BE(0)
         });
         Object.defineProperty(this, "state", {
             enumerable: true,
@@ -225,6 +220,32 @@ class Connection {
             writable: true,
             value: void 0
         });
+        /** RFC 7675 consent-to-send: application data may use the selected pair. */
+        Object.defineProperty(this, "consentFresh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Invalidates in-flight consent callbacks on restart / close / replace / expire. */
+        Object.defineProperty(this, "consentSessionId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "consentExpiryTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "consentRequestAbort", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "onData", {
             enumerable: true,
             configurable: true,
@@ -243,7 +264,7 @@ class Connection {
             writable: true,
             value: new common_1.Event()
         });
-        // 4.1.1.4 ? 生存確認 life check
+        // RFC 7675 consent freshness
         Object.defineProperty(this, "queryConsent", {
             enumerable: true,
             configurable: true,
@@ -252,70 +273,164 @@ class Connection {
                 if (this.iceLite) {
                     return;
                 }
-                if (this.queryConsentHandle) {
-                    this.queryConsentHandle.resolve();
-                }
-                this.queryConsentHandle = (0, helper_1.cancelable)(async (_, __, onCancel) => {
-                    let failures = 0;
+                // Invalidate any previous consent session before starting a new one.
+                this.stopConsentLifecycle();
+                const sessionId = this.consentSessionId;
+                this.consentFresh = true;
+                const handle = (0, helper_1.cancelable)(async (_, __, onCancel) => {
                     let canceled = false;
                     const cancelEvent = new AbortController();
+                    const clearConsentExpiry = () => {
+                        if (this.consentExpiryTimer === undefined) {
+                            return;
+                        }
+                        clearTimeout(this.consentExpiryTimer);
+                        this.consentExpiryTimer = undefined;
+                    };
+                    const refreshConsentExpiry = () => {
+                        // Only the active session may refresh the shared expiry timer.
+                        if (canceled || sessionId !== this.consentSessionId) {
+                            return;
+                        }
+                        clearConsentExpiry();
+                        this.consentExpiryTimer = setTimeout(() => {
+                            this.consentExpiryTimer = undefined;
+                            if (canceled || sessionId !== this.consentSessionId) {
+                                return;
+                            }
+                            if (this.state === "closed" || this.state === "failed") {
+                                return;
+                            }
+                            log("Consent to send expired");
+                            // Expire independently of request cadence / failure count (RFC 7675).
+                            this.consentFresh = false;
+                            this.consentSessionId++;
+                            this.consentRequestAbort?.abort();
+                            this.consentRequestAbort = undefined;
+                            if (this.queryConsentHandle === handle) {
+                                this.queryConsentHandle = undefined;
+                            }
+                            canceled = true;
+                            cancelEvent.abort();
+                            // Transport stays available for ICE restart; explicit close() uses "closed".
+                            this.setState("failed");
+                        }, iceBase_1.CONSENT_TIMEOUT * 1000);
+                    };
                     onCancel.once(() => {
                         canceled = true;
-                        failures += iceBase_1.CONSENT_FAILURES;
+                        // Avoid clearing a replacement session's timer/handle.
+                        if (sessionId === this.consentSessionId) {
+                            clearConsentExpiry();
+                            this.consentRequestAbort?.abort();
+                            this.consentRequestAbort = undefined;
+                        }
                         cancelEvent.abort();
-                        this.queryConsentHandle = undefined;
+                        if (this.queryConsentHandle === handle) {
+                            this.queryConsentHandle = undefined;
+                        }
                     });
-                    const { localUsername, remoteUsername, iceControlling } = this;
-                    // """
-                    // Periodically check consent (RFC 7675).
-                    // """
+                    // Initial ICE check success is the first valid consent response.
+                    refreshConsentExpiry();
+                    const randomizedConsentInterval = () => iceBase_1.CONSENT_INTERVAL * (0.8 + 0.4 * Math.random()) * 1000;
+                    // Cadence is measured between request *starts*, not response completions.
+                    let nextConsentAt = Date.now() + randomizedConsentInterval();
+                    const isTerminalState = () => this.state === "closed" || this.state === "failed";
                     try {
-                        while (this.state !== "closed" && !canceled) {
-                            // # randomize between 0.8 and 1.2 times CONSENT_INTERVAL
-                            await timers.setTimeout(iceBase_1.CONSENT_INTERVAL * (0.8 + 0.4 * Math.random()) * 1000, undefined, { signal: cancelEvent.signal });
+                        while (!isTerminalState() &&
+                            !canceled &&
+                            sessionId === this.consentSessionId) {
+                            await this.abortableDelay(Math.max(0, nextConsentAt - Date.now()), cancelEvent.signal);
+                            if (canceled ||
+                                isTerminalState() ||
+                                sessionId !== this.consentSessionId) {
+                                break;
+                            }
+                            // Fix next start time before awaiting any response (independent timers).
+                            nextConsentAt = Date.now() + randomizedConsentInterval();
                             const nominated = this.nominated;
-                            if (!nominated || canceled) {
+                            if (!nominated) {
                                 break;
                             }
+                            const pairId = nominated.id;
+                            const generation = this.generation;
+                            const remotePassword = this.remotePassword;
+                            const { localUsername, remoteUsername, iceControlling } = this;
                             const request = this.buildRequest({
-                                nominate: false,
+                                nominate: this.shouldNominateConsentRequest(nominated),
                                 localUsername,
                                 remoteUsername,
                                 iceControlling,
                                 localCandidate: nominated.localCandidate,
                             });
-                            try {
-                                nominated.consentRequestsSent++;
-                                nominated.requestsSent++;
-                                await nominated.protocol.request(request, nominated.remoteAddr, Buffer.from(this.remotePassword, "utf8"), 0, (attempt) => {
+                            this.consentRequestAbort?.abort();
+                            const requestAbort = new AbortController();
+                            this.consentRequestAbort = requestAbort;
+                            nominated.consentRequestsSent++;
+                            nominated.requestsSent++;
+                            // RTT-aware wait (floor 500ms); independent of retransmissions: 0.
+                            const responseTimeout = (0, iceBase_1.consentResponseTimeoutMs)(nominated.rtt);
+                            const requestStartedAt = performance.now();
+                            // Do not await here: response wait must not stretch the 4–6s cadence.
+                            nominated.protocol
+                                .request(request, nominated.remoteAddr, Buffer.from(remotePassword, "utf8"), {
+                                retransmissions: 0,
+                                responseTimeout,
+                                signal: requestAbort.signal,
+                                onRequestSent: (attempt) => {
                                     if (attempt > 0) {
                                         nominated.retransmissionsSent++;
                                     }
-                                });
+                                },
+                            })
+                                .then(() => {
+                                // Accept only responses for the current pair / generation / session.
+                                // Address / MESSAGE-INTEGRITY / response class are enforced in Transaction + protocol.
+                                if (sessionId !== this.consentSessionId || canceled) {
+                                    return;
+                                }
+                                const state = this.state;
+                                if (state === "closed" || state === "failed") {
+                                    return;
+                                }
+                                if (this.nominated?.id !== pairId) {
+                                    return;
+                                }
+                                if (this.generation !== generation) {
+                                    return;
+                                }
+                                if (this.remotePassword !== remotePassword) {
+                                    return;
+                                }
+                                const rtt = (performance.now() - requestStartedAt) / 1000; // seconds
+                                nominated.rtt = rtt;
+                                nominated.totalRoundTripTime += rtt;
+                                nominated.roundTripTimeMeasurements++;
                                 nominated.responsesReceived++;
-                                failures = 0;
-                                if (this.state === "disconnected") {
+                                this.consentFresh = true;
+                                refreshConsentExpiry();
+                                if (state === "disconnected") {
                                     this.setState("connected");
                                 }
-                            }
-                            catch (error) {
-                                if (nominated.id === this.nominated?.id) {
-                                    log("no stun response");
-                                    failures++;
-                                    this.setState("disconnected");
-                                    break;
+                            })
+                                .catch((error) => {
+                                // Individual request loss is expected; keep monitoring (RFC 7675).
+                                if (sessionId === this.consentSessionId &&
+                                    this.nominated?.id === pairId) {
+                                    log("no stun response", error);
                                 }
-                            }
-                            if (failures >= iceBase_1.CONSENT_FAILURES) {
-                                log("Consent to send expired");
-                                this.queryConsentHandle = undefined;
-                                this.setState("closed");
-                                break;
-                            }
+                            });
+                        }
+                    }
+                    catch (error) {
+                        // Abort during delay is normal on cancel / expire.
+                    }
+                    finally {
+                        if (sessionId === this.consentSessionId) {
+                            clearConsentExpiry();
                         }
                     }
-                    catch (error) { }
                 });
+                this.queryConsentHandle = handle;
             }
         });
         Object.defineProperty(this, "send", {
@@ -323,17 +438,15 @@ class Connection {
             configurable: true,
             writable: true,
             value: async (data) => {
-                const activePair = this.nominated;
-                if (activePair) {
-                    await activePair.protocol.sendData(data, activePair.remoteAddr);
-                    // Update statistics
-                    activePair.packetsSent++;
-                    activePair.bytesSent += data.length;
-                }
-                else {
-                    // log("Cannot send data, ice not connected");
+                // RFC 7675: after consent expiry, do not send application data on the 5-tuple.
+                if (!this.canSendApplicationData()) {
                     return;
                 }
+                const activePair = this.nominated;
+                await activePair.protocol.sendData(data, activePair.remoteAddr);
+                // Update statistics
+                activePair.packetsSent++;
+                activePair.bytesSent += data.length;
             }
         });
         // 3.  Terminology : Check
@@ -421,7 +534,8 @@ class Connection {
                     }
                 }
                 // # check remote address matches
-                if (!(0, fast_deep_equal_1.default)(result.addr, pair.remoteAddr)) {
+                if (result.addr[0] !== pair.remoteAddr[0] ||
+                    result.addr[1] !== pair.remoteAddr[1]) {
                     pair.updateState(iceBase_1.CandidatePairState.FAILED);
                     this.checkComplete(pair);
                     r();
@@ -496,13 +610,13 @@ class Connection {
         if (this.iceLite) {
             value = false;
         }
-        if (this.generation > 0 || this.nominated) {
+        // While a pair is selected, keep the negotiated role. ICE restart clears
+        // `nominated`, so offer/answer role and RFC 8445 role-conflict repair can
+        // reassign controlling/controlled for the new generation.
+        if (this.nominated) {
             return;
         }
-        this._iceControlling = value;
-        for (const pair of this.checkList) {
-            pair.iceControlling = value;
-        }
+        this.applyIceControlling(value);
     }
     get iceLite() {
         return this.options.iceLite;
@@ -542,13 +656,15 @@ class Connection {
                 protocol.localCandidate.ufrag = this.localUsername;
             }
         }
-        this.queryConsentHandle?.resolve?.();
-        this.queryConsentHandle = undefined;
+        // Tear down consent timers/transactions; new credentials require a new session.
+        this.stopConsentLifecycle();
     }
     resetNominatedPair() {
         log("resetNominatedPair");
         this.nominated = undefined;
         this.nominating = false;
+        // Drop old pair's consent timers/transactions; restarted when a new pair is nominated.
+        this.stopConsentLifecycle();
     }
     setRemoteParams({ iceLite, usernameFragment, password, }) {
         log("setRemoteParams", { iceLite, usernameFragment, password });
@@ -560,6 +676,15 @@ class Connection {
     async gatherCandidates() {
         if (!this.localCandidatesStart) {
             this.localCandidatesStart = true;
+            // ICE restart keeps transport protocols; re-advertise their host candidates
+            // with the new generation / ufrag before gathering additional addresses.
+            for (const protocol of this.protocols) {
+                if (protocol.localCandidate) {
+                    protocol.localCandidate.generation = this.generation;
+                    protocol.localCandidate.ufrag = this.localUsername;
+                    this.appendLocalCandidate(protocol.localCandidate);
+                }
+            }
             let address = (0, utils_1.getHostAddresses)(this.options.useIpv4, this.options.useIpv6, {
                 useLinkLocalAddress: this.options.useLinkLocalAddress,
             });
@@ -921,13 +1046,69 @@ class Connection {
         }
         return false;
     }
+    /**
+     * Stop consent request cadence, expiry timer, and outstanding transactions.
+     * Does not change ICE state by itself.
+     */
+    stopConsentLifecycle() {
+        this.consentSessionId++;
+        this.consentFresh = false;
+        if (this.consentExpiryTimer !== undefined) {
+            clearTimeout(this.consentExpiryTimer);
+            this.consentExpiryTimer = undefined;
+        }
+        this.consentRequestAbort?.abort();
+        this.consentRequestAbort = undefined;
+        const handle = this.queryConsentHandle;
+        this.queryConsentHandle = undefined;
+        // Resolve after clearing the field so a stale onCancel cannot wipe a replacement.
+        handle?.resolve?.();
+    }
+    /**
+     * ICE-lite interop only (not required by RFC 7675): mirror libwebrtc
+     * semi-aggressive nomination — attach USE-CANDIDATE when we are controlling,
+     * the remote is ICE-lite, and the target is the current selected pair.
+     */
+    shouldNominateConsentRequest(pair) {
+        return (this.iceControlling && this.remoteIsLite && this.nominated?.id === pair.id);
+    }
+    canSendApplicationData() {
+        if (!this.nominated) {
+            return false;
+        }
+        if (this.state === "closed" || this.state === "failed") {
+            return false;
+        }
+        // Local ICE-lite does not run consent checks; full agents need fresh consent.
+        if (this.iceLite) {
+            return true;
+        }
+        return this.consentFresh;
+    }
+    abortableDelay(ms, signal) {
+        return new Promise((resolve, reject) => {
+            if (signal.aborted) {
+                reject(new DOMException("The operation was aborted", "AbortError"));
+                return;
+            }
+            const timer = setTimeout(() => {
+                signal.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(new DOMException("The operation was aborted", "AbortError"));
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+    }
     async close() {
         // """
         // Close the connection.
         // """
         this.setState("closed");
         // # stop consent freshness tests
-        this.queryConsentHandle?.resolve?.();
+        this.stopConsentLifecycle();
         // # stop check list
         if (this.checkList && !this.checkListDone) {
             this.checkListState.put(new Promise((r) => {
@@ -1013,13 +1194,23 @@ class Connection {
         (0, iceBase_1.sortCandidatePairs)(this.checkList, this.iceControlling);
     }
     findPair(protocol, remoteCandidate) {
-        const pair = this.checkList.find((pair) => (0, fast_deep_equal_1.default)(pair.protocol, protocol) &&
-            (0, fast_deep_equal_1.default)(pair.remoteCandidate, remoteCandidate));
+        const pair = this.checkList.find((pair) => pair.protocol === protocol && pair.remoteCandidate === remoteCandidate);
         return pair;
     }
+    applyIceControlling(iceControlling) {
+        this._iceControlling = iceControlling;
+        for (const pair of this.checkList) {
+            pair.iceControlling = iceControlling;
+        }
+    }
     switchRole(iceControlling) {
         log("switch role", iceControlling);
-        this.iceControlling = iceControlling;
+        // Role conflicts must be repaired even after a prior generation or while
+        // connectivity checks are in flight (RFC 8445 §7.2.5.1 / §7.3.1.1).
+        if (this.iceLite) {
+            iceControlling = false;
+        }
+        this.applyIceControlling(iceControlling);
         this.sortCheckList();
     }
     checkComplete(pair) {
@@ -1040,6 +1231,12 @@ class Connection {
                 this.nominated = pair;
                 this.nominating = false;
                 this.pruneTcpConnections(pair);
+                // After resetNominatedPair / renomination while already connected,
+                // restart consent freshness on the new selected pair.
+                if (!this.iceLite &&
+                    (this.state === "connected" || this.state === "completed")) {
+                    this.queryConsent();
+                }
                 // 8.1.2.  Updating States
                 // The agent MUST remove all Waiting and Frozen pairs in the check
                 // list and triggered check queue for the same component as the