@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/sctp/transport.js

@@ -0,0 +1,23 @@
+export class UdpTransport {
+    constructor(upd, rinfo) {
+        this.upd = upd;
+        this.rinfo = rinfo;
+        this.send = (buf) => new Promise((r, f) => this.upd.send(buf, this.rinfo.port, this.rinfo.address, (err) => {
+            if (err) {
+                f(err);
+            }
+            else {
+                r();
+            }
+        }));
+        upd.on('message', (buf, target) => {
+            this.rinfo = target;
+            if (this.onData)
+                this.onData(buf);
+        });
+    }
+    close() {
+        this.upd.close();
+    }
+}
+export const createUdpTransport = (socket, rinfo = {}) => new UdpTransport(socket, rinfo);

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

@@ -0,0 +1,9 @@
+export * from './protocol.js';
+export * from './node/server.js';
+export * from './node/turnServer.js';
+export * from './stun/attributes.js';
+export * from './stun/const.js';
+export * from './stun/message.js';
+export * from './turn/auth.js';
+export * from './turn/frame.js';
+export * from './turn/protocol.js';

package/dist/esm/lib/turn/node/server.js

@@ -0,0 +1,89 @@
+import { createSocket } from 'node:dgram';
+import { debug, detached } from '../../common/index.js';
+const log = debug('webrtc/turn/stun-server');
+import { StunServerProtocol } from '../protocol.js';
+export class NodeStunServer {
+    constructor(options = {}) {
+        const { host = '0.0.0.0', port = 3478, type = 'udp4', software = 'lakutata-webrtc', ...protocolOptions } = options;
+        this.host = host;
+        this.port = port;
+        this.type = type;
+        this.protocol = new StunServerProtocol({
+            software,
+            ...protocolOptions
+        });
+    }
+    get address() {
+        if (!this.socket) {
+            return undefined;
+        }
+        const address = this.socket.address();
+        if (typeof address === 'string') {
+            return undefined;
+        }
+        return [normalizeAddress(address.address), address.port];
+    }
+    async listen() {
+        if (this.socket) {
+            return;
+        }
+        const socket = createSocket(this.type);
+        this.socket = socket;
+        socket.on('message', detached((data, remoteInfo) => this.handleMessage(data, remoteInfo), (error) => log('message failed', error)));
+        await new Promise((resolve, reject) => {
+            socket.once('error', reject);
+            socket.bind({ address: this.host, port: this.port }, () => {
+                socket.off('error', reject);
+                resolve();
+            });
+        });
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        const socket = this.socket;
+        this.socket = undefined;
+        await new Promise((resolve) => {
+            socket.once('close', resolve);
+            socket.close();
+        });
+    }
+    async handleMessage(data, remoteInfo) {
+        if (!this.socket) {
+            return;
+        }
+        const localAddress = this.address;
+        const actions = this.protocol.handleDatagram({
+            data,
+            remoteAddress: [normalizeAddress(remoteInfo.address), remoteInfo.port],
+            localAddress,
+            transport: transportFromSocketType(this.type)
+        });
+        for (const action of actions) {
+            if (action.type !== 'send') {
+                continue;
+            }
+            await new Promise((resolve, reject) => {
+                this.socket?.send(action.data, action.remoteAddress[1], action.remoteAddress[0], (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+    }
+}
+export async function createNodeStunServer(options = {}) {
+    const server = new NodeStunServer(options);
+    await server.listen();
+    return server;
+}
+function normalizeAddress(address) {
+    return address.split('%')[0];
+}
+function transportFromSocketType(type) {
+    return type === 'udp6' || type === 'udp4' ? 'udp' : 'udp';
+}

package/dist/esm/lib/turn/node/turnServer.js

@@ -0,0 +1,560 @@
+import { randomUUID } from 'node:crypto';
+import { createSocket } from 'node:dgram';
+import { createServer } from 'node:net';
+import { networkInterfaces } from 'node:os';
+import { createServer as createTlsServer } from 'node:tls';
+import { debug, detached, growReceiveBuffer } from '../../common/index.js';
+const log = debug('webrtc/turn/server');
+import { padTurnFrame } from '../turn/frame.js';
+import { TurnServerProtocol } from '../turn/protocol.js';
+export class NodeTurnServer {
+    constructor(options = {}) {
+        this.tcpConnections = new Map();
+        this.tlsConnections = new Map();
+        this.relaySockets = new Map();
+        //The address of each relay socket by its port, and the port of each relay: a packet of a peer coming from one of
+        //them is known without asking each socket its address (a system call) at each packet
+        this.relayBoundByPort = new Map();
+        this.relayPorts = new Map();
+        //Set while closed: the clients closing afterwards do not arm the timer again
+        this.closed = false;
+        const { host = '0.0.0.0', port = 3478, relayAddress = host === '0.0.0.0' ? '127.0.0.1' : host, relayBindAddress = host, relayPortRange, udp = true, tcp = true, credentials, tls, getPassword, software = 'lakutata-webrtc', reusePort = false, ...protocolOptions } = options;
+        this.reusePort = reusePort;
+        this.host = host;
+        this.port = port;
+        this.udpEnabled = udp;
+        this.tcpEnabled = tcp;
+        this.tlsEnabled = tls !== undefined;
+        this.tlsExternal = Boolean(tls?.external);
+        this.tlsOptions = tls;
+        this.tlsPort = tls?.port ?? (port === 0 ? 0 : 5349);
+        this.relayAddress = relayAddress;
+        this.relayBindAddress = relayBindAddress;
+        if (relayPortRange && relayPortRange[0] > relayPortRange[1]) {
+            throw new Error(`relayPortRange: the first port (${relayPortRange[0]}) is above the last one (${relayPortRange[1]})`);
+        }
+        this.relayPortRange = relayPortRange;
+        this.protocol = new TurnServerProtocol({
+            software,
+            getPassword: getPassword ?? ((username, _realm) => credentials?.[username]),
+            ...protocolOptions
+        });
+    }
+    get address() {
+        if (this.boundPort === undefined) {
+            return undefined;
+        }
+        return [this.relayAddress, this.boundPort];
+    }
+    get tlsAddress() {
+        if (this.boundTlsPort === undefined) {
+            return undefined;
+        }
+        return [this.relayAddress, this.boundTlsPort];
+    }
+    async listen() {
+        if (this.boundPort !== undefined || this.boundTlsPort !== undefined) {
+            return;
+        }
+        this.closed = false;
+        if (!this.udpEnabled && !this.tcpEnabled && !this.tlsEnabled) {
+            throw new Error('NodeTurnServer requires udp, tcp, or tls to be enabled');
+        }
+        if (this.tcpEnabled &&
+            this.tlsEnabled &&
+            !this.tlsExternal &&
+            this.tlsPort !== 0 &&
+            this.tlsPort === this.port) {
+            throw new Error('NodeTurnServer cannot share the same port for tcp and tls');
+        }
+        if (this.tlsEnabled &&
+            !this.tlsExternal &&
+            (!this.tlsOptions?.key || !this.tlsOptions?.cert)) {
+            throw new Error('NodeTurnServer tls requires both key and cert');
+        }
+        // With port 0, UDP picks an ephemeral port and TCP reuses that number.
+        // The number may already be taken on the TCP side, so pick a new one.
+        const sharesEphemeralPort = this.port === 0 && this.udpEnabled && this.tcpEnabled;
+        const maxAttempts = sharesEphemeralPort ? SHARED_PORT_BIND_ATTEMPTS : 1;
+        for (let attempt = 1;; attempt++) {
+            try {
+                await this.listenTransports();
+                break;
+            }
+            catch (error) {
+                // Never leave a half-open server behind (e.g. UDP bound, TCP failed).
+                await this.closeListeners();
+                if (isAddressInUseError(error) && attempt < maxAttempts) {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        this.updateTimer();
+    }
+    async listenTransports() {
+        if (this.udpEnabled) {
+            await this.listenUdp();
+        }
+        if (this.tcpEnabled) {
+            await this.listenTcp(this.boundPort ?? this.port);
+        }
+        if (this.tlsEnabled) {
+            if (this.tlsExternal) {
+                if (this.tlsPort !== 0) {
+                    this.boundTlsPort = this.tlsPort;
+                }
+            }
+            else {
+                await this.listenTls(this.tlsPort);
+            }
+        }
+    }
+    attachTlsSocket(socket, options = {}) {
+        if (!this.tlsEnabled) {
+            throw new Error('NodeTurnServer tls must be enabled before attaching sockets');
+        }
+        this.handleStreamConnection(socket, 'tls', options);
+    }
+    async close() {
+        this.closed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        for (const connection of this.tcpConnections.values()) {
+            connection.destroy();
+        }
+        this.tcpConnections.clear();
+        for (const connection of this.tlsConnections.values()) {
+            connection.destroy();
+        }
+        this.tlsConnections.clear();
+        const relayClosers = [...this.relaySockets.values()].map((socket) => new Promise((resolve) => {
+            socket.once('close', resolve);
+            socket.close();
+        }));
+        this.relaySockets.clear();
+        this.relayBoundByPort.clear();
+        this.relayPorts.clear();
+        await Promise.all([...relayClosers, this.closeListeners()]);
+    }
+    async closeListeners() {
+        const closers = [];
+        if (this.udpSocket) {
+            const udpSocket = this.udpSocket;
+            this.udpSocket = undefined;
+            closers.push(new Promise((resolve) => {
+                udpSocket.once('close', resolve);
+                udpSocket.close();
+            }));
+        }
+        if (this.tcpServer) {
+            const tcpServer = this.tcpServer;
+            this.tcpServer = undefined;
+            closers.push(new Promise((resolve) => {
+                tcpServer.close(() => resolve());
+            }));
+        }
+        if (this.tlsServer) {
+            const tlsServer = this.tlsServer;
+            this.tlsServer = undefined;
+            closers.push(new Promise((resolve) => {
+                tlsServer.close(() => resolve());
+            }));
+        }
+        this.boundPort = undefined;
+        this.boundTlsPort = undefined;
+        await Promise.all(closers);
+    }
+    async listenUdp() {
+        const socket = createSocket({ type: this.socketType(this.host), reusePort: this.reusePort });
+        this.udpSocket = socket;
+        socket.on('message', detached(async (data, remoteInfo) => {
+            await this.executeActions(this.protocol.handleClientDatagram({
+                clientId: udpClientId(remoteInfo),
+                data,
+                remoteAddress: [
+                    normalizeAddress(remoteInfo.address),
+                    remoteInfo.port
+                ],
+                localAddress: this.address,
+                transport: 'udp'
+            }));
+        }, (error) => log('client datagram failed', error)));
+        await new Promise((resolve, reject) => {
+            socket.once('error', reject);
+            socket.bind({ address: this.host, port: this.port }, () => {
+                socket.off('error', reject);
+                const address = socket.address();
+                if (typeof address === 'string') {
+                    reject(new Error('Expected UDP address info'));
+                    return;
+                }
+                this.boundPort = address.port;
+                growReceiveBuffer(socket);
+                resolve();
+            });
+        });
+    }
+    async listenTcp(port) {
+        const server = createServer((socket) => {
+            this.handleStreamConnection(socket, 'tcp');
+        });
+        this.tcpServer = server;
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen({ port, host: this.host, reusePort: this.reusePort }, () => {
+                server.off('error', reject);
+                const address = server.address();
+                if (!address || typeof address === 'string') {
+                    reject(new Error('Expected TCP address info'));
+                    return;
+                }
+                this.boundPort = address.port;
+                resolve();
+            });
+        });
+    }
+    async listenTls(port) {
+        const server = createTlsServer(this.tlsOptions, (socket) => {
+            this.handleStreamConnection(socket, 'tls');
+        });
+        this.tlsServer = server;
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen({ port, host: this.host, reusePort: this.reusePort }, () => {
+                server.off('error', reject);
+                const address = server.address();
+                if (!address || typeof address === 'string') {
+                    reject(new Error('Expected TLS address info'));
+                    return;
+                }
+                this.boundTlsPort = address.port;
+                resolve();
+            });
+        });
+    }
+    async executeActions(actions) {
+        let scheduleAt;
+        for (const action of actions) {
+            switch (action.type) {
+                case 'send-client':
+                    await this.sendClient(action);
+                    break;
+                case 'send-relay':
+                    await this.sendRelay(action);
+                    break;
+                case 'bind-relay':
+                    await this.bindRelay(action.allocationId, action.relayId);
+                    break;
+                case 'close-relay':
+                    await this.closeRelay(action.relayId);
+                    break;
+                case 'close-client':
+                    this.closeClient(action.clientId);
+                    break;
+                case 'schedule-timeout':
+                    scheduleAt = action.at;
+                    break;
+                default:
+                    break;
+            }
+        }
+        //The packets relayed change no expiry: the timer moves only when the protocol schedules it
+        if (scheduleAt !== undefined)
+            this.setTimer(scheduleAt);
+    }
+    async sendClient(action) {
+        if (action.transport === 'tcp' || action.transport === 'tls') {
+            const socket = this.getStreamClient(action.transport, action.clientId);
+            if (!socket || socket.destroyed) {
+                return;
+            }
+            await new Promise((resolve, reject) => {
+                socket.write(padTurnFrame(action.data), (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            }).catch(async (error) => {
+                if (!isClosedTcpWriteError(error)) {
+                    throw error;
+                }
+                await this.executeActions(this.protocol.handleClientClosed({ clientId: action.clientId }));
+            });
+            return;
+        }
+        if (action.transport !== 'udp') {
+            return;
+        }
+        if (!this.udpSocket) {
+            return;
+        }
+        //Not waiting for the send: a datagram not sent is lost, as on the network
+        this.udpSocket.send(padTurnFrame(action.data), action.remoteAddress[1], action.remoteAddress[0]);
+    }
+    async sendRelay(action) {
+        const relaySocket = this.relaySockets.get(action.relayId);
+        if (!relaySocket) {
+            return;
+        }
+        //Not waiting for the send: a datagram not sent is lost, as on the network
+        relaySocket.send(action.data, action.remoteAddress[1], action.remoteAddress[0]);
+    }
+    //A UDP socket bound to the relay address: on a free port of relayPortRange (from a random one), else on any port
+    async bindRelaySocket() {
+        const bind = (port) => new Promise((resolve, reject) => {
+            const socket = createSocket(this.socketType(this.relayBindAddress));
+            socket.once('error', (error) => {
+                try {
+                    socket.close();
+                }
+                catch {
+                    //Already closed
+                }
+                reject(error);
+            });
+            socket.bind({ address: this.relayBindAddress, port }, () => {
+                socket.removeAllListeners('error');
+                growReceiveBuffer(socket);
+                resolve(socket);
+            });
+        });
+        if (!this.relayPortRange)
+            return bind(0);
+        const [min, max] = this.relayPortRange;
+        const count = max - min + 1;
+        const start = Math.floor(Math.random() * count);
+        let lastError;
+        for (let i = 0; i < count; i++) {
+            try {
+                return await bind(min + ((start + i) % count));
+            }
+            catch (error) {
+                lastError = error;
+                if (error.code !== 'EADDRINUSE')
+                    break;
+            }
+        }
+        throw lastError ?? new Error('no free port in the relay port range');
+    }
+    async bindRelay(allocationId, relayId) {
+        try {
+            const socket = await this.bindRelaySocket();
+            this.relaySockets.set(relayId, socket);
+            socket.on('error', (error) => log('relay socket error', error));
+            const address = socket.address();
+            if (typeof address === 'string') {
+                throw new Error('Expected relay UDP address info');
+            }
+            this.relayBoundByPort.set(address.port, address);
+            this.relayPorts.set(relayId, address.port);
+            socket.on('message', detached(async (data, remoteInfo) => {
+                await this.executeActions(this.protocol.handleRelayPacket({
+                    relayId,
+                    data,
+                    remoteAddress: this.normalizeRelayRemoteAddress(remoteInfo),
+                    localAddress: [this.relayAddress, address.port]
+                }));
+            }, (error) => log('relay datagram failed', error)));
+            await this.executeActions(this.protocol.handleRelayBound({
+                allocationId,
+                relayId,
+                relayedAddress: [this.relayAddress, address.port]
+            }));
+        }
+        catch (error) {
+            log('relay bind failed', error);
+            const socket = this.relaySockets.get(relayId);
+            this.relaySockets.delete(relayId);
+            this.forgetRelayPort(relayId);
+            try {
+                socket?.close();
+            }
+            catch {
+                //Already closed
+            }
+            await this.executeActions(this.protocol.handleRelayBindFailure({
+                allocationId
+            }));
+        }
+    }
+    async closeRelay(relayId) {
+        const relaySocket = this.relaySockets.get(relayId);
+        if (!relaySocket) {
+            return;
+        }
+        this.relaySockets.delete(relayId);
+        this.forgetRelayPort(relayId);
+        await new Promise((resolve) => {
+            relaySocket.once('close', resolve);
+            relaySocket.close();
+        });
+    }
+    closeClient(clientId) {
+        const socket = this.tcpConnections.get(clientId);
+        if (socket && !socket.destroyed) {
+            socket.destroy();
+            return;
+        }
+        const tlsSocket = this.tlsConnections.get(clientId);
+        if (tlsSocket && !tlsSocket.destroyed) {
+            tlsSocket.destroy();
+        }
+    }
+    updateTimer() {
+        const nextTimeoutAt = this.protocol.nextTimeoutAt;
+        if (nextTimeoutAt === undefined) {
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.timer = undefined;
+            return;
+        }
+        this.setTimer(nextTimeoutAt);
+    }
+    /**
+     * Run the timer of the protocol at a time
+     * @param nextTimeoutAt
+     */
+    setTimer(nextTimeoutAt) {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        if (this.closed)
+            return;
+        this.timer = setTimeout(detached(async () => {
+            this.timer = undefined;
+            await this.executeActions(this.protocol.handleTimer());
+        }, (error) => log('timer failed', error)), Math.max(0, nextTimeoutAt - Date.now()));
+    }
+    normalizeRelayRemoteAddress(remoteInfo) {
+        const remoteAddress = normalizeAddress(remoteInfo.address);
+        //Only a relay socket of the port of the packet can be its sender
+        const bound = this.relayBoundByPort.get(remoteInfo.port);
+        if (bound && this.isRelaySocketAddress(bound, remoteAddress, remoteInfo.port)) {
+            return [this.relayAddress, remoteInfo.port];
+        }
+        return [remoteAddress, remoteInfo.port];
+    }
+    isRelaySocketAddress(address, remoteAddress, remotePort) {
+        if (address.port !== remotePort) {
+            return false;
+        }
+        const boundAddress = normalizeAddress(address.address);
+        return (boundAddress === remoteAddress ||
+            ((isWildcardAddress(boundAddress) ||
+                this.isLocalInterfaceAddress(boundAddress)) &&
+                this.isLocalInterfaceAddress(remoteAddress)));
+    }
+    isLocalInterfaceAddress(address) {
+        if (address === this.relayAddress) {
+            return true;
+        }
+        const now = Date.now();
+        if (!this.interfaceAddresses || now - this.interfaceAddresses.at > 1000) {
+            const addresses = new Set();
+            for (const candidate of Object.values(networkInterfaces()).flat()) {
+                if (candidate)
+                    addresses.add(normalizeAddress(candidate.address));
+            }
+            this.interfaceAddresses = { at: now, addresses };
+        }
+        return this.interfaceAddresses.addresses.has(address);
+    }
+    /**
+     * A relay closed: its port is not one of a relay any more
+     * @param relayId
+     */
+    forgetRelayPort(relayId) {
+        const port = this.relayPorts.get(relayId);
+        this.relayPorts.delete(relayId);
+        if (port !== undefined)
+            this.relayBoundByPort.delete(port);
+    }
+    socketType(address) {
+        return address.includes(':') ? 'udp6' : 'udp4';
+    }
+    handleStreamConnection(socket, transport, options = {}) {
+        const clientId = randomUUID();
+        const localAddress = options.localAddress ?? this.resolveStreamLocalAddress(socket, transport);
+        if (transport === 'tcp') {
+            this.tcpConnections.set(clientId, socket);
+        }
+        else {
+            this.tlsConnections.set(clientId, socket);
+        }
+        const handleData = async (data) => {
+            await this.executeActions(this.protocol.handleTcpChunk({
+                clientId,
+                data,
+                remoteAddress: [
+                    normalizeAddress(socket.remoteAddress ?? ''),
+                    socket.remotePort ?? 0
+                ],
+                localAddress,
+                transport
+            }));
+        };
+        socket.on('data', (data) => {
+            void handleData(data);
+        });
+        socket.on('close', detached(async () => {
+            if (transport === 'tcp') {
+                this.tcpConnections.delete(clientId);
+            }
+            else {
+                this.tlsConnections.delete(clientId);
+            }
+            await this.executeActions(this.protocol.handleClientClosed({ clientId }));
+        }, (error) => log('client close failed', error)));
+        socket.on('error', () => { });
+        if (options.initialData?.length) {
+            void handleData(options.initialData);
+        }
+    }
+    getStreamClient(transport, clientId) {
+        return transport === 'tcp'
+            ? this.tcpConnections.get(clientId)
+            : this.tlsConnections.get(clientId);
+    }
+    resolveStreamLocalAddress(socket, transport) {
+        if (socket.localAddress && socket.localPort) {
+            return [
+                normalizeAddress(socket.localAddress),
+                socket.localPort
+            ];
+        }
+        return transport === 'tcp' ? this.address : this.tlsAddress;
+    }
+}
+export async function createNodeTurnServer(options = {}) {
+    const server = new NodeTurnServer(options);
+    await server.listen();
+    return server;
+}
+function normalizeAddress(address) {
+    return address.split('%')[0];
+}
+function isWildcardAddress(address) {
+    return address === '0.0.0.0' || address === '::';
+}
+const SHARED_PORT_BIND_ATTEMPTS = 10;
+function isAddressInUseError(error) {
+    return (!!error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        error.code === 'EADDRINUSE');
+}
+function isClosedTcpWriteError(error) {
+    const code = error && typeof error === 'object' && 'code' in error
+        ? error.code
+        : undefined;
+    return (code === 'ECONNRESET' || code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED');
+}
+function udpClientId(remoteInfo) {
+    return `udp:${normalizeAddress(remoteInfo.address)}:${remoteInfo.port}`;
+}