@lakutata/webrtc 0.0.0-stage → 3.1.4

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StunProtocol = void 0;
+const common_js_1 = require("../imports/common.js");
+const const_js_1 = require("./const.js");
+const message_js_1 = require("./message.js");
+const transaction_js_1 = require("./transaction.js");
+const log = (0, common_js_1.debug)('webrtc/ice/stun/protocol');
+class StunProtocol {
+    static { this.type = 'stun'; }
+    get transactionsKeys() {
+        return Object.keys(this.transactions);
+    }
+    constructor() {
+        this.type = StunProtocol.type;
+        this.transactions = {};
+        this.onRequestReceived = new common_js_1.Event();
+        this.onDataReceived = new common_js_1.Event();
+        this.connectionMade = async (useIpv4, portRange, interfaceAddresses) => {
+            if (useIpv4) {
+                this.transport = await common_js_1.UdpTransport.init('udp4', {
+                    portRange,
+                    interfaceAddresses
+                });
+            }
+            else {
+                this.transport = await common_js_1.UdpTransport.init('udp6', {
+                    portRange,
+                    interfaceAddresses
+                });
+            }
+            this.transport.onData = (data, addr) => {
+                this.datagramReceived(data, addr);
+            };
+        };
+    }
+    datagramReceived(data, addr) {
+        try {
+            const message = (0, message_js_1.parseMessage)(data);
+            if (!message) {
+                if (this.localCandidate) {
+                    this.onDataReceived.execute(data);
+                }
+                return;
+            }
+            // log("parseMessage", addr, message.toJSON());
+            if ((message.messageClass === const_js_1.classes.RESPONSE ||
+                message.messageClass === const_js_1.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
+                    ? (0, message_js_1.parseMessage)(data, transaction.integrityKey)
+                    : message;
+                if (!verified) {
+                    log('STUN response failed MESSAGE-INTEGRITY check');
+                    return;
+                }
+                transaction.responseReceived(verified, addr);
+            }
+            else if (message.messageClass === const_js_1.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 (0, transaction_js_1.resolveRequestAddress)(addr, this.transport.addressFamily);
+        const options = (0, transaction_js_1.buildTransactionOptions)(integrityKey, retransmissionsOrOptions, onRequestSent);
+        const transaction = new transaction_js_1.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();
+    }
+}
+exports.StunProtocol = StunProtocol;

package/dist/cjs/lib/ice/stun/tcpFrame.d.ts

@@ -0,0 +1,5 @@
+export declare function encodeTcpFrame(data: Buffer): Buffer<ArrayBuffer>;
+export declare function splitTcpFrames(buffer: Buffer): {
+    frames: Buffer<ArrayBufferLike>[];
+    rest: Buffer<ArrayBufferLike>;
+};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeTcpFrame = encodeTcpFrame;
+exports.splitTcpFrames = splitTcpFrames;
+function encodeTcpFrame(data) {
+    const header = Buffer.alloc(2);
+    header.writeUInt16BE(data.length, 0);
+    return Buffer.concat([header, data]);
+}
+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)
+    };
+}

package/dist/cjs/lib/ice/stun/tcpProtocol.d.ts

@@ -0,0 +1,57 @@
+import { type AddressInfo, type Socket } from 'node:net';
+import type { Candidate } from '../candidate.js';
+import { type Address, Event } from '../imports/common.js';
+import type { Protocol, TransactionRequestOptions } from '../types/model.js';
+import { type Message } from './message.js';
+import { Transaction } from './transaction.js';
+type SocketEntry = {
+    socket: Socket;
+    buffer: Buffer;
+    remoteAddr?: Address;
+};
+declare abstract class BaseTcpProtocol implements Protocol {
+    static readonly type = "tcp";
+    readonly type = "tcp";
+    transactions: {
+        [key: string]: Transaction;
+    };
+    localCandidate?: Candidate;
+    sentMessage?: Message;
+    localIp?: string;
+    readonly onRequestReceived: Event<[Message, readonly [string, number], Buffer<ArrayBufferLike>]>;
+    readonly onDataReceived: Event<[Buffer<ArrayBufferLike>]>;
+    /** The connection to this remote address was closed (by either side). */
+    readonly onConnectionClosed: Event<[readonly [string, number]]>;
+    protected readonly sockets: Map<string, SocketEntry>;
+    abstract connectionMade(...args: any[]): Promise<void>;
+    protected abstract getSocket(addr: Address): Promise<SocketEntry>;
+    protected rememberSocket(entry: SocketEntry): void;
+    /** Drop `entry` only if it is still the socket registered for its address. */
+    protected forgetSocket(entry: SocketEntry): boolean;
+    /** Registered socket for `addr`, discarding it if it is already closed. */
+    protected getOpenSocket(addr: Address): SocketEntry | undefined;
+    private dropSocket;
+    protected registerSocket(socket: Socket, remoteAddr?: Address): SocketEntry;
+    private handleFrame;
+    private sendFrame;
+    sendStun(message: Message, addr: Address): Promise<void>;
+    sendData(data: Buffer, addr: Address): Promise<void>;
+    request(request: Message, addr: Address, integrityKey?: Buffer, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): Promise<[Message, readonly [string, number]]>;
+    pruneForSelection(remoteAddr?: Address): Promise<void>;
+    get activeSocketCount(): number;
+    get address(): AddressInfo;
+    close(): Promise<void>;
+}
+export declare class TcpActiveProtocol extends BaseTcpProtocol {
+    private readonly pendingSockets;
+    connectionMade(localIp: string): Promise<void>;
+    protected getSocket(addr: Address): Promise<SocketEntry>;
+}
+export declare class TcpPassiveProtocol extends BaseTcpProtocol {
+    private server;
+    connectionMade(localIp: string, portRange?: [number, number]): Promise<void>;
+    protected getSocket(addr: Address): Promise<SocketEntry>;
+    get listeningPort(): number;
+    close(): Promise<void>;
+}
+export {};

package/dist/cjs/lib/ice/stun/tcpProtocol.js

@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TcpPassiveProtocol = exports.TcpActiveProtocol = void 0;
+const node_net_1 = require("node:net");
+const common_js_1 = require("../imports/common.js");
+const const_js_1 = require("./const.js");
+const message_js_1 = require("./message.js");
+const tcpFrame_js_1 = require("./tcpFrame.js");
+const transaction_js_1 = require("./transaction.js");
+const log = (0, common_js_1.debug)('webrtc/ice/stun/tcpProtocol');
+function socketKey(addr) {
+    return `${addr[0]}:${addr[1]}`;
+}
+function isSocketClosed(socket) {
+    return socket.destroyed || socket.writableEnded;
+}
+function addressFromSocket(socket) {
+    if (!socket.remoteAddress || !socket.remotePort) {
+        return;
+    }
+    return [socket.remoteAddress, socket.remotePort];
+}
+async function waitForListening(server, host, port) {
+    return await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off('listening', onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen({
+            host,
+            port: port ?? 0,
+            exclusive: true
+        });
+    });
+}
+class BaseTcpProtocol {
+    constructor() {
+        this.type = BaseTcpProtocol.type;
+        this.transactions = {};
+        this.onRequestReceived = new common_js_1.Event();
+        this.onDataReceived = new common_js_1.Event();
+        /** The connection to this remote address was closed (by either side). */
+        this.onConnectionClosed = new common_js_1.Event();
+        this.sockets = new Map();
+    }
+    static { this.type = 'tcp'; }
+    rememberSocket(entry) {
+        const remoteAddr = entry.remoteAddr;
+        if (!remoteAddr) {
+            return;
+        }
+        this.sockets.set(socketKey(remoteAddr), entry);
+    }
+    /** Drop `entry` only if it is still the socket registered for its address. */
+    forgetSocket(entry) {
+        const remoteAddr = entry.remoteAddr;
+        if (!remoteAddr) {
+            return false;
+        }
+        const key = socketKey(remoteAddr);
+        if (this.sockets.get(key) !== entry) {
+            return false;
+        }
+        this.sockets.delete(key);
+        return true;
+    }
+    /** Registered socket for `addr`, discarding it if it is already closed. */
+    getOpenSocket(addr) {
+        const entry = this.sockets.get(socketKey(addr));
+        if (!entry) {
+            return;
+        }
+        if (isSocketClosed(entry.socket)) {
+            this.dropSocket(entry);
+            return;
+        }
+        return entry;
+    }
+    dropSocket(entry) {
+        entry.socket.destroy();
+        if (this.forgetSocket(entry) && entry.remoteAddr) {
+            this.onConnectionClosed.execute(entry.remoteAddr);
+        }
+    }
+    registerSocket(socket, remoteAddr) {
+        const entry = {
+            socket,
+            buffer: Buffer.alloc(0),
+            remoteAddr
+        };
+        if (remoteAddr) {
+            this.rememberSocket(entry);
+        }
+        socket.on('data', (data) => {
+            entry.buffer = Buffer.concat([entry.buffer, data]);
+            const { frames, rest } = (0, tcpFrame_js_1.splitTcpFrames)(entry.buffer);
+            entry.buffer = rest;
+            const socketAddr = entry.remoteAddr ?? addressFromSocket(socket);
+            if (!entry.remoteAddr && socketAddr) {
+                entry.remoteAddr = socketAddr;
+                this.rememberSocket(entry);
+            }
+            if (!socketAddr) {
+                return;
+            }
+            for (const frame of frames) {
+                if (frame.length === 0) {
+                    continue;
+                }
+                this.handleFrame(frame, socketAddr);
+            }
+        });
+        socket.on('close', () => {
+            if (this.forgetSocket(entry) && entry.remoteAddr) {
+                this.onConnectionClosed.execute(entry.remoteAddr);
+            }
+        });
+        socket.on('error', (error) => {
+            log('tcp socket error', error);
+        });
+        return entry;
+    }
+    handleFrame(data, addr) {
+        try {
+            const message = (0, message_js_1.parseMessage)(data);
+            if (!message) {
+                this.onDataReceived.execute(data);
+                return;
+            }
+            if ((message.messageClass === const_js_1.classes.RESPONSE ||
+                message.messageClass === const_js_1.classes.ERROR) &&
+                this.transactions[message.transactionIdHex]) {
+                const transaction = this.transactions[message.transactionIdHex];
+                const verified = transaction.integrityKey
+                    ? (0, message_js_1.parseMessage)(data, transaction.integrityKey)
+                    : message;
+                if (!verified) {
+                    log('STUN response failed MESSAGE-INTEGRITY check');
+                    return;
+                }
+                transaction.responseReceived(verified, addr);
+            }
+            else if (message.messageClass === const_js_1.classes.REQUEST) {
+                this.onRequestReceived.execute(message, addr, data);
+            }
+        }
+        catch (error) {
+            log('tcp frame parse error', error);
+        }
+    }
+    async sendFrame(data, addr) {
+        const entry = await this.getSocket(addr);
+        try {
+            await new Promise((resolve, reject) => {
+                entry.socket.write((0, tcpFrame_js_1.encodeTcpFrame)(data), (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            // EPIPE / ECONNRESET / ERR_STREAM_DESTROYED: this connection is gone.
+            // Forget it so the next send does not reuse it, and report the failure.
+            log('tcp write failed', addr, error);
+            this.dropSocket(entry);
+            throw error;
+        }
+    }
+    async sendStun(message, addr) {
+        await this.sendFrame(message.bytes, addr);
+    }
+    async sendData(data, addr) {
+        await this.sendFrame(data, addr);
+    }
+    async request(request, addr, integrityKey, retransmissionsOrOptions, onRequestSent) {
+        if (this.transactions[request.transactionIdHex]) {
+            throw new Error('already requested');
+        }
+        if (integrityKey) {
+            request.addMessageIntegrity(integrityKey);
+            request.addFingerprint();
+        }
+        const resolvedAddr = await (0, transaction_js_1.resolveRequestAddress)(addr);
+        const options = {
+            // A failed connect/write will not be fixed by waiting for a response.
+            failOnSendError: true,
+            ...(0, transaction_js_1.buildTransactionOptions)(integrityKey, retransmissionsOrOptions, onRequestSent)
+        };
+        const transaction = new transaction_js_1.Transaction(request, resolvedAddr, this, options);
+        this.transactions[request.transactionIdHex] = transaction;
+        try {
+            return await transaction.run();
+        }
+        finally {
+            delete this.transactions[request.transactionIdHex];
+        }
+    }
+    async pruneForSelection(remoteAddr) {
+        for (const [key, entry] of this.sockets.entries()) {
+            if (remoteAddr && key === socketKey(remoteAddr)) {
+                continue;
+            }
+            entry.socket.destroy();
+            this.sockets.delete(key);
+        }
+    }
+    get activeSocketCount() {
+        return this.sockets.size;
+    }
+    get address() {
+        return {};
+    }
+    async close() {
+        Object.values(this.transactions).forEach((transaction) => {
+            transaction.cancel();
+        });
+        await this.pruneForSelection();
+        this.onRequestReceived.complete();
+        this.onDataReceived.complete();
+        this.onConnectionClosed.complete();
+    }
+}
+class TcpActiveProtocol extends BaseTcpProtocol {
+    constructor() {
+        super(...arguments);
+        this.pendingSockets = new Map();
+    }
+    async connectionMade(localIp) {
+        this.localIp = localIp;
+    }
+    async getSocket(addr) {
+        const key = socketKey(addr);
+        const existing = this.getOpenSocket(addr);
+        if (existing) {
+            return existing;
+        }
+        const pending = this.pendingSockets.get(key);
+        if (pending) {
+            return await pending;
+        }
+        const connecting = new Promise((resolve, reject) => {
+            const socket = (0, node_net_1.connect)({
+                host: addr[0],
+                port: addr[1],
+                localAddress: this.localIp
+            });
+            const entry = this.registerSocket(socket, addr);
+            const onError = (error) => {
+                socket.off('connect', onConnect);
+                reject(error);
+            };
+            const onConnect = () => {
+                socket.off('error', onError);
+                resolve(entry);
+            };
+            socket.once('error', onError);
+            socket.once('connect', onConnect);
+        });
+        this.pendingSockets.set(key, connecting);
+        try {
+            return await connecting;
+        }
+        finally {
+            this.pendingSockets.delete(key);
+        }
+    }
+}
+exports.TcpActiveProtocol = TcpActiveProtocol;
+class TcpPassiveProtocol extends BaseTcpProtocol {
+    constructor() {
+        super(...arguments);
+        this.server = (0, node_net_1.createServer)((socket) => {
+            this.registerSocket(socket, addressFromSocket(socket));
+        });
+    }
+    async connectionMade(localIp, portRange) {
+        this.localIp = localIp;
+        if (portRange) {
+            let lastError;
+            for (let port = portRange[0]; port <= portRange[1]; port++) {
+                try {
+                    await waitForListening(this.server, localIp, port);
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                }
+            }
+            throw lastError ?? new Error('tcp port not found');
+        }
+        await waitForListening(this.server, localIp);
+    }
+    async getSocket(addr) {
+        const entry = this.getOpenSocket(addr);
+        if (!entry) {
+            throw new Error('tcp passive connection not established');
+        }
+        return entry;
+    }
+    get listeningPort() {
+        const address = this.server.address();
+        if (!address || typeof address === 'string') {
+            throw new Error('tcp passive protocol is not listening');
+        }
+        return address.port;
+    }
+    async close() {
+        await super.close();
+        await new Promise((resolve) => {
+            this.server.close(() => resolve());
+        });
+    }
+}
+exports.TcpPassiveProtocol = TcpPassiveProtocol;

package/dist/cjs/lib/ice/stun/transaction.d.ts

@@ -0,0 +1,75 @@
+import { type Address } from '../imports/common.js';
+import type { Protocol, TransactionRequestOptions } from '../types/model.js';
+import type { Message } from './message.js';
+/**
+ * Resolve a request target to a concrete IP before creating a Transaction so
+ * response source-address checks match the UDP peer address (hostname ≠ IP).
+ *
+ * `family` is the family of the socket that will carry the request: a
+ * hostname resolves only in that family, and an IP literal of the other
+ * family throws AddressFamilyMismatch instead of retransmitting into a send
+ * that cannot succeed. Family 0 means unknown: no preference, no check.
+ */
+export declare function resolveRequestAddress(addr: Address, family?: 0 | 4 | 6): Promise<Address>;
+/**
+ * Normalize legacy positional args and the options-object form into one shape.
+ * Existing callers pass `(retransmissions?, onRequestSent?)`.
+ */
+export declare function normalizeTransactionOptions(retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): TransactionRequestOptions;
+/**
+ * Compare ICE transport addresses (host, port).
+ * IPv6 literals are compared in canonical form because the socket reports
+ * `::1` even when the peer was configured as `0:0:0:0:0:0:0:1`.
+ */
+export declare function addressEquals(a: Address, b: Address): boolean;
+export declare class Transaction {
+    private request;
+    private addr;
+    private protocol;
+    private timeoutDelay;
+    ended: boolean;
+    private tries;
+    private readonly triesMax;
+    private readonly onResponse;
+    private readonly onRequestSent?;
+    private readonly signal?;
+    private readonly failOnSendError;
+    /** Remote address this transaction was sent to; responses must match. */
+    readonly expectedAddr: Address;
+    /**
+   * When set, protocol layers re-parse the wire response with this key so
+   * MESSAGE-INTEGRITY failures are rejected before responseReceived.
+   */
+    readonly integrityKey?: Buffer;
+    private waitTimer?;
+    private waitResolve?;
+    private onAbort?;
+    constructor(request: Message, addr: Address, protocol: Protocol, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void);
+    /**
+   * Accept a matching authenticated non-error response from the expected
+   * remote address. Wrong address, missing MESSAGE-INTEGRITY (when required),
+   * or non-success class is rejected without completing the transaction
+   * (wrong address / unauthenticated responses are ignored so we keep waiting).
+   */
+    responseReceived: (message: Message, addr: Address) => void;
+    run: () => Promise<[Message, readonly [string, number]]>;
+    private attachAbortListener;
+    private failWithTimeout;
+    private fail;
+    private clearWait;
+    private wait;
+    private retry;
+    cancel(): void;
+}
+/**
+ * Whether an error response is a challenge of long-term credentials: a 401
+ * or 438 (Stale Nonce) with a new NONCE. A server cannot protect it with the
+ * key of the nonce it rejects, so it comes without MESSAGE-INTEGRITY and the
+ * client retries with the new nonce (RFC 8489, section 9.2.5).
+ */
+export declare function isChallenge(message: Message): boolean;
+/**
+ * Build Transaction options for Protocol.request, folding integrityKey into
+ * options so response path can re-verify MESSAGE-INTEGRITY.
+ */
+export declare function buildTransactionOptions(integrityKey: Buffer | undefined, retransmissionsOrOptions?: number | TransactionRequestOptions, onRequestSent?: (attempt: number) => void): TransactionRequestOptions;