@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/sctp/transport.d.ts

@@ -0,0 +1,15 @@
+import type { RemoteInfo, Socket } from 'node:dgram';
+export interface Transport {
+    onData?: (buf: Buffer) => void;
+    send: (buf: Buffer) => Promise<void>;
+    close: () => void;
+}
+export declare class UdpTransport implements Transport {
+    private upd;
+    private rinfo;
+    constructor(upd: Socket, rinfo: Partial<RemoteInfo>);
+    onData?: (buf: Buffer) => void;
+    send: (buf: Buffer) => Promise<void>;
+    close(): void;
+}
+export declare const createUdpTransport: (socket: Socket, rinfo?: Partial<RemoteInfo>) => UdpTransport;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUdpTransport = exports.UdpTransport = void 0;
+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();
+    }
+}
+exports.UdpTransport = UdpTransport;
+const createUdpTransport = (socket, rinfo = {}) => new UdpTransport(socket, rinfo);
+exports.createUdpTransport = createUdpTransport;

package/dist/cjs/lib/turn/index.d.ts

@@ -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/cjs/lib/turn/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./protocol.js"), exports);
+__exportStar(require("./node/server.js"), exports);
+__exportStar(require("./node/turnServer.js"), exports);
+__exportStar(require("./stun/attributes.js"), exports);
+__exportStar(require("./stun/const.js"), exports);
+__exportStar(require("./stun/message.js"), exports);
+__exportStar(require("./turn/auth.js"), exports);
+__exportStar(require("./turn/frame.js"), exports);
+__exportStar(require("./turn/protocol.js"), exports);

package/dist/cjs/lib/turn/node/server.d.ts

@@ -0,0 +1,21 @@
+import { type SocketType } from 'node:dgram';
+import { type Address } from '../../common/index.js';
+import { StunServerProtocol, type StunServerProtocolOptions } from '../protocol.js';
+export interface NodeStunServerOptions extends StunServerProtocolOptions {
+    host?: string;
+    port?: number;
+    type?: SocketType;
+}
+export declare class NodeStunServer {
+    readonly protocol: StunServerProtocol;
+    private socket?;
+    private readonly host;
+    private readonly port;
+    private readonly type;
+    constructor(options?: NodeStunServerOptions);
+    get address(): Address | undefined;
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    private handleMessage;
+}
+export declare function createNodeStunServer(options?: NodeStunServerOptions): Promise<NodeStunServer>;

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeStunServer = void 0;
+exports.createNodeStunServer = createNodeStunServer;
+const node_dgram_1 = require("node:dgram");
+const index_js_1 = require("../../common/index.js");
+const log = (0, index_js_1.debug)('webrtc/turn/stun-server');
+const protocol_js_1 = require("../protocol.js");
+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 protocol_js_1.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 = (0, node_dgram_1.createSocket)(this.type);
+        this.socket = socket;
+        socket.on('message', (0, index_js_1.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();
+                });
+            });
+        }
+    }
+}
+exports.NodeStunServer = NodeStunServer;
+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/cjs/lib/turn/node/turnServer.d.ts

@@ -0,0 +1,91 @@
+import { type TLSSocket, type TlsOptions } from 'node:tls';
+import { type Address } from '../../common/index.js';
+import { TurnServerProtocol, type TurnServerProtocolOptions } from '../turn/protocol.js';
+export interface NodeTurnServerTlsOptions extends TlsOptions {
+    external?: boolean;
+    port?: number;
+}
+export interface NodeTurnServerAttachTlsSocketOptions {
+    initialData?: Buffer;
+    localAddress?: Address;
+}
+export interface NodeTurnServerOptions extends TurnServerProtocolOptions {
+    host?: string;
+    port?: number;
+    relayAddress?: string;
+    relayBindAddress?: string;
+    /**the UDP ports of the relays (the firewall or the container publishes this range); any free port by default */
+    relayPortRange?: [number, number];
+    credentials?: Record<string, string>;
+    udp?: boolean;
+    tcp?: boolean;
+    tls?: NodeTurnServerTlsOptions;
+    /**the listeners bound with SO_REUSEPORT, to share their ports with the servers of other threads (Linux): the system
+     * keeps each client on one of them */
+    reusePort?: boolean;
+}
+export declare class NodeTurnServer {
+    readonly protocol: TurnServerProtocol;
+    private udpSocket?;
+    private tcpServer?;
+    private tlsServer?;
+    private readonly tcpConnections;
+    private readonly tlsConnections;
+    private readonly relaySockets;
+    private readonly relayBoundByPort;
+    private readonly relayPorts;
+    private interfaceAddresses?;
+    private timer?;
+    private closed;
+    private readonly host;
+    private readonly port;
+    private readonly udpEnabled;
+    private readonly tcpEnabled;
+    private readonly tlsEnabled;
+    private readonly tlsExternal;
+    private readonly tlsOptions?;
+    private readonly tlsPort;
+    private readonly relayAddress;
+    private readonly relayBindAddress;
+    private readonly relayPortRange?;
+    private boundPort?;
+    private boundTlsPort?;
+    private readonly reusePort;
+    constructor(options?: NodeTurnServerOptions);
+    get address(): Address | undefined;
+    get tlsAddress(): Address | undefined;
+    listen(): Promise<void>;
+    private listenTransports;
+    attachTlsSocket(socket: TLSSocket, options?: NodeTurnServerAttachTlsSocketOptions): void;
+    close(): Promise<void>;
+    private closeListeners;
+    private listenUdp;
+    private listenTcp;
+    private listenTls;
+    private executeActions;
+    private sendClient;
+    private sendRelay;
+    private bindRelaySocket;
+    private bindRelay;
+    private closeRelay;
+    private closeClient;
+    private updateTimer;
+    /**
+     * Run the timer of the protocol at a time
+     * @param nextTimeoutAt
+     */
+    private setTimer;
+    private normalizeRelayRemoteAddress;
+    private isRelaySocketAddress;
+    private isLocalInterfaceAddress;
+    /**
+     * A relay closed: its port is not one of a relay any more
+     * @param relayId
+     */
+    private forgetRelayPort;
+    private socketType;
+    private handleStreamConnection;
+    private getStreamClient;
+    private resolveStreamLocalAddress;
+}
+export declare function createNodeTurnServer(options?: NodeTurnServerOptions): Promise<NodeTurnServer>;