@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/ice/iceBase.js

@@ -0,0 +1,172 @@
+import { randomUUID } from 'node:crypto';
+import { Candidate, candidateFoundation, candidatePriority } from './candidate.js';
+import { debug } from './imports/common.js';
+import { classes, methods } from './stun/const.js';
+import { Message } from './stun/message.js';
+const log = debug('webrtc/ice/iceBase:log');
+export class CandidatePair {
+    get state() {
+        return this._state;
+    }
+    toJSON() {
+        return this.json;
+    }
+    get json() {
+        return {
+            protocol: this.protocol.type,
+            localCandidate: this.localCandidate.toSdp(),
+            remoteCandidate: this.remoteCandidate.toSdp()
+        };
+    }
+    constructor(protocol, remoteCandidate, iceControlling) {
+        this.protocol = protocol;
+        this.remoteCandidate = remoteCandidate;
+        this.iceControlling = iceControlling;
+        this.id = randomUUID().toString();
+        this.nominated = false;
+        this.remoteNominated = false;
+        // 5.7.4.  Computing States
+        this._state = CandidatePairState.FROZEN;
+        // Statistics tracking
+        this.packetsSent = 0;
+        this.packetsReceived = 0;
+        this.bytesSent = 0;
+        this.bytesReceived = 0;
+        this.totalRoundTripTime = 0;
+        this.roundTripTimeMeasurements = 0;
+        this.requestsReceived = 0;
+        this.requestsSent = 0;
+        this.responsesReceived = 0;
+        this.responsesSent = 0;
+        this.retransmissionsReceived = 0;
+        this.retransmissionsSent = 0;
+        this.consentRequestsSent = 0;
+        this.requestTransactionIds = new Set();
+    }
+    updateState(state) {
+        this._state = state;
+    }
+    get localCandidate() {
+        if (!this.protocol.localCandidate) {
+            throw new Error('localCandidate not exist');
+        }
+        return this.protocol.localCandidate;
+    }
+    get remoteAddr() {
+        return [this.remoteCandidate.host, this.remoteCandidate.port];
+    }
+    get component() {
+        return this.localCandidate.component;
+    }
+    get priority() {
+        return candidatePairPriority(this.localCandidate, this.remoteCandidate, this.iceControlling);
+    }
+    get foundation() {
+        return this.localCandidate.foundation;
+    }
+    noteIncomingRequest(transactionId) {
+        const isRetransmission = this.requestTransactionIds.has(transactionId);
+        if (!isRetransmission) {
+            this.requestTransactionIds.add(transactionId);
+            return false;
+        }
+        this.retransmissionsReceived++;
+        return true;
+    }
+}
+export const ICE_COMPLETED = 1;
+export const ICE_FAILED = 2;
+/** Basic consent check period in seconds (RFC 7675). Actual interval is 0.8–1.2× this. */
+export const CONSENT_INTERVAL = 5;
+/**
+ * @deprecated Consent expiry is based on {@link CONSENT_TIMEOUT} (30s after the
+ * last valid response), not a consecutive failure count. Kept for API compatibility.
+ */
+export const CONSENT_FAILURES = 6;
+/** RFC 7675: consent expires this many seconds after the last valid response. */
+export const CONSENT_TIMEOUT = 30;
+/**
+ * Default single-shot response wait for consent requests (ms) when RTT is unknown.
+ * Independent of retransmission count. Downstream ICE-lite peers typically
+ * answer in 150–300ms; 1s is a conservative default used by interop patches.
+ */
+export const CONSENT_RESPONSE_TIMEOUT = 1000;
+/** RFC 8445 §14.3: ICE RTO must not be less than 500ms. */
+export const CONSENT_RESPONSE_TIMEOUT_MIN = 500;
+/**
+ * Compute consent response wait from pair RTT (seconds).
+ * Uses 2×RTT + 200ms jitter margin, floored at {@link CONSENT_RESPONSE_TIMEOUT_MIN}.
+ * Falls back to {@link CONSENT_RESPONSE_TIMEOUT} when RTT is unavailable.
+ */
+export function consentResponseTimeoutMs(rttSeconds) {
+    if (rttSeconds === undefined ||
+        !Number.isFinite(rttSeconds) ||
+        rttSeconds <= 0) {
+        return CONSENT_RESPONSE_TIMEOUT;
+    }
+    return Math.max(CONSENT_RESPONSE_TIMEOUT_MIN, Math.round(rttSeconds * 1000 * 2 + 200));
+}
+export var CandidatePairState;
+(function (CandidatePairState) {
+    CandidatePairState[CandidatePairState["FROZEN"] = 0] = "FROZEN";
+    CandidatePairState[CandidatePairState["WAITING"] = 1] = "WAITING";
+    CandidatePairState[CandidatePairState["IN_PROGRESS"] = 2] = "IN_PROGRESS";
+    CandidatePairState[CandidatePairState["SUCCEEDED"] = 3] = "SUCCEEDED";
+    CandidatePairState[CandidatePairState["FAILED"] = 4] = "FAILED";
+})(CandidatePairState || (CandidatePairState = {}));
+export const defaultOptions = {
+    iceLite: false,
+    useTcp: false,
+    useIpv4: true,
+    useIpv6: true
+};
+export function validateRemoteCandidate(candidate) {
+    // """
+    // Check the remote candidate is supported.
+    // """
+    if (!['host', 'relay', 'srflx'].includes(candidate.type))
+        throw new Error(`Unexpected candidate type "${candidate.type}"`);
+    // ipaddress.ip_address(candidate.host)
+    return candidate;
+}
+export function sortCandidatePairs(pairs, iceControlling) {
+    return pairs
+        .sort((a, b) => candidatePairPriority(a.localCandidate, a.remoteCandidate, iceControlling) -
+        candidatePairPriority(b.localCandidate, b.remoteCandidate, iceControlling))
+        .reverse();
+}
+// 5.7.2.  Computing Pair Priority and Ordering Pairs
+export function candidatePairPriority(local, remote, iceControlling) {
+    const G = (iceControlling && local.priority) || remote.priority;
+    const D = (iceControlling && remote.priority) || local.priority;
+    return (1 << 32) * Math.min(G, D) + 2 * Math.max(G, D) + (G > D ? 1 : 0);
+}
+export async function serverReflexiveCandidate(protocol, stunServer) {
+    // """
+    // Query STUN server to obtain a server-reflexive candidate.
+    // """
+    // # perform STUN query
+    const request = new Message(methods.BINDING, classes.REQUEST);
+    try {
+        const [response] = await protocol.request(request, stunServer);
+        const localCandidate = protocol.localCandidate;
+        if (!localCandidate) {
+            throw new Error('not exist');
+        }
+        const candidate = new Candidate(candidateFoundation('srflx', localCandidate.transport, localCandidate.host, stunServer[0]), localCandidate.component, localCandidate.transport, candidatePriority('srflx', {
+            transport: localCandidate.transport,
+            tcptype: localCandidate.tcptype
+        }), response.getAttributeValue('XOR-MAPPED-ADDRESS')[0], response.getAttributeValue('XOR-MAPPED-ADDRESS')[1], 'srflx', localCandidate.host, localCandidate.port, localCandidate.tcptype);
+        return candidate;
+    }
+    catch (error) {
+        // todo fix
+        log('error serverReflexiveCandidate', error);
+    }
+}
+export function validateAddress(addr) {
+    if (addr && Number.isNaN(addr[1])) {
+        return [addr[0], 443];
+    }
+    return addr;
+}

package/dist/esm/lib/ice/imports/common.js

@@ -0,0 +1 @@
+export * from '../../common/index.js';

package/dist/esm/lib/ice/index.js

@@ -0,0 +1,12 @@
+export { randomPort } from '../common/index.js';
+export * from './stun/const.js';
+export * from './stun/tcpFrame.js';
+export * from './stun/tcpProtocol.js';
+export * from './stun/message.js';
+export * from './stun/protocol.js';
+export * from './turn/protocol.js';
+export * from './candidate.js';
+export * from './ice.js';
+export * from './types/model.js';
+export * from './utils.js';
+export * from './iceBase.js';

package/dist/esm/lib/ice/internal/selectAddresses.js

@@ -0,0 +1,36 @@
+import { normalizeFamilyNodeV18 } from '../imports/common.js';
+/**
+ * Interface 辞書から host 候補アドレスを選別する（package-private）。
+ * 公開 barrel (`src/index.ts`) からは export しない。
+ * テストは本 helper への依存注入で行う。
+ */
+export function selectAddressesFromInterfaces(interfaces, family, options = {}, isLinkLocal) {
+    // https://chromium.googlesource.com/external/webrtc/+/master/rtc_base/network.cc#236
+    const costlyNetworks = ['ipsec', 'tun', 'utun', 'tap'];
+    const banNetworks = ['vmnet', 'veth'];
+    const { useLinkLocalAddress } = options;
+    const all = Object.keys(interfaces)
+        .map((nic) => {
+        for (const word of [...costlyNetworks, ...banNetworks]) {
+            if (nic.startsWith(word)) {
+                return {
+                    nic,
+                    addresses: []
+                };
+            }
+        }
+        const addresses = (interfaces[nic] ?? []).filter((details) => normalizeFamilyNodeV18(details.family) === family &&
+            !details.internal &&
+            (useLinkLocalAddress ? true : !isLinkLocal(details)));
+        return {
+            nic,
+            addresses: addresses.map((address) => address.address)
+        };
+    })
+        .filter((address) => !!address);
+    // os.networkInterfaces doesn't actually return addresses in a good order.
+    // have seen instances where en0 (ethernet) is after en1 (wlan), etc.
+    // eth0 > eth1
+    all.sort((a, b) => a.nic.localeCompare(b.nic));
+    return Object.values(all).flatMap((entry) => entry.addresses);
+}

package/dist/esm/lib/ice/stun/attributes.js

@@ -0,0 +1 @@
+export * from '../../turn/stun/attributes.js';

package/dist/esm/lib/ice/stun/const.js

@@ -0,0 +1,8 @@
+export * from '../../turn/stun/const.js';
+/**
+ * Response deadline for ICE connectivity checks over TCP (RFC 6544).
+ * Reliable transports send each STUN request once (RFC 5389 §7.2.2), so this
+ * single wait has to cover the TCP connect of an active candidate as well as
+ * the request/response round trip on a loaded host.
+ */
+export const TCP_CHECK_RESPONSE_TIMEOUT_MS = 3000;

package/dist/esm/lib/ice/stun/message.js

@@ -0,0 +1 @@
+export * from '../../turn/stun/message.js';

package/dist/esm/lib/ice/stun/protocol.js

@@ -0,0 +1,121 @@
+import { Event, UdpTransport, debug } from '../imports/common.js';
+import { classes } from './const.js';
+import { parseMessage } from './message.js';
+import { Transaction, buildTransactionOptions, resolveRequestAddress } from './transaction.js';
+const log = debug('webrtc/ice/stun/protocol');
+export class StunProtocol {
+    static { this.type = 'stun'; }
+    get transactionsKeys() {
+        return Object.keys(this.transactions);
+    }
+    constructor() {
+        this.type = StunProtocol.type;
+        this.transactions = {};
+        this.onRequestReceived = new Event();
+        this.onDataReceived = new Event();
+        this.connectionMade = async (useIpv4, portRange, interfaceAddresses) => {
+            if (useIpv4) {
+                this.transport = await UdpTransport.init('udp4', {
+                    portRange,
+                    interfaceAddresses
+                });
+            }
+            else {
+                this.transport = await UdpTransport.init('udp6', {
+                    portRange,
+                    interfaceAddresses
+                });
+            }
+            this.transport.onData = (data, addr) => {
+                this.datagramReceived(data, addr);
+            };
+        };
+    }
+    datagramReceived(data, addr) {
+        try {
+            const message = parseMessage(data);
+            if (!message) {
+                if (this.localCandidate) {
+                    this.onDataReceived.execute(data);
+                }
+                return;
+            }
+            // log("parseMessage", addr, message.toJSON());
+            if ((message.messageClass === classes.RESPONSE ||
+                message.messageClass === classes.ERROR) &&
+                this.transactionsKeys.includes(message.transactionIdHex)) {
+                const transaction = this.transactions[message.transactionIdHex];
+                // Re-parse with integrity key so unauthenticated responses are dropped.
+                const verified = transaction.integrityKey
+                    ? parseMessage(data, transaction.integrityKey)
+                    : message;
+                if (!verified) {
+                    log('STUN response failed MESSAGE-INTEGRITY check');
+                    return;
+                }
+                transaction.responseReceived(verified, addr);
+            }
+            else if (message.messageClass === classes.REQUEST) {
+                this.onRequestReceived.execute(message, addr, data);
+            }
+        }
+        catch (error) {
+            log('datagramReceived error', error);
+        }
+    }
+    getExtraInfo() {
+        const { address: host, port } = this.transport.address;
+        return [host, port];
+    }
+    async sendStun(message, addr) {
+        if (this.transport.closed) {
+            return;
+        }
+        const data = message.bytes;
+        await this.transport.send(data, addr).catch(() => {
+            log('sendStun failed', addr, message);
+        });
+    }
+    async sendData(data, addr) {
+        if (this.transport.closed) {
+            return;
+        }
+        await this.transport.send(data, addr);
+    }
+    connectTo(addr) {
+        this.transport?.connectTo(addr);
+    }
+    disconnect() {
+        this.transport?.disconnect();
+    }
+    async request(request, addr, integrityKey, retransmissionsOrOptions, onRequestSent) {
+        // """
+        // Execute a STUN transaction and return the response.
+        // """
+        if (this.transactionsKeys.includes(request.transactionIdHex))
+            throw new Error('already request ed');
+        if (integrityKey) {
+            request.addMessageIntegrity(integrityKey);
+            request.addFingerprint();
+        }
+        // Match DNS family to the bound socket so STUN hostname targets resolve correctly.
+        const resolvedAddr = await resolveRequestAddress(addr, this.transport.addressFamily);
+        const options = buildTransactionOptions(integrityKey, retransmissionsOrOptions, onRequestSent);
+        const transaction = new Transaction(request, resolvedAddr, this, options);
+        this.transactions[request.transactionIdHex] = transaction;
+        try {
+            return await transaction.run();
+        }
+        finally {
+            delete this.transactions[request.transactionIdHex];
+        }
+    }
+    async close() {
+        Object.values(this.transactions).forEach((transaction) => {
+            transaction.cancel();
+        });
+        await this.transport.close();
+        this.onRequestReceived.complete();
+        this.onDataReceived.complete();
+    }
+}

package/dist/esm/lib/ice/stun/tcpFrame.js

@@ -0,0 +1,21 @@
+export function encodeTcpFrame(data) {
+    const header = Buffer.alloc(2);
+    header.writeUInt16BE(data.length, 0);
+    return Buffer.concat([header, data]);
+}
+export function splitTcpFrames(buffer) {
+    const frames = [];
+    let offset = 0;
+    while (buffer.length - offset >= 2) {
+        const length = buffer.readUInt16BE(offset);
+        if (buffer.length - offset < length + 2) {
+            break;
+        }
+        frames.push(buffer.subarray(offset + 2, offset + 2 + length));
+        offset += 2 + length;
+    }
+    return {
+        frames,
+        rest: buffer.subarray(offset)
+    };
+}