@lakutata/webrtc 0.0.0-stage → 3.1.1

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

@@ -0,0 +1,387 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCSctpCapabilities = exports.RTCSctpTransport = exports.DEFAULT_MAX_MESSAGE_SIZE = void 0;
+const node_crypto_1 = require("node:crypto");
+const common_js_1 = require("../imports/common.js");
+const index_js_1 = require("../../sctp/index.js");
+const const_js_1 = require("../const.js");
+const dataChannel_js_1 = require("../dataChannel.js");
+const log = (0, common_js_1.debug)('webrtc/peer/transport/sctp');
+exports.DEFAULT_MAX_MESSAGE_SIZE = 65536;
+class RTCSctpTransport {
+    constructor(port = 5000, maxMessageSize = exports.DEFAULT_MAX_MESSAGE_SIZE, sctpOptions = {}) {
+        this.port = port;
+        this.maxMessageSize = maxMessageSize;
+        this.sctpOptions = sctpOptions;
+        this.onDataChannel = new common_js_1.Event();
+        this.id = (0, node_crypto_1.randomUUID)().toString();
+        this.bundled = false;
+        this.dataChannels = {};
+        this.remoteMaxMessageSize = exports.DEFAULT_MAX_MESSAGE_SIZE;
+        this.dataChannelQueue = [];
+        this.eventDisposer = [];
+        this.datachannelReceive = async (streamId, ppId, data) => {
+            if (ppId === const_js_1.WEBRTC_DCEP && data.length > 0) {
+                log('DCEP', streamId, ppId, data);
+                switch (data[0]) {
+                    case const_js_1.DATA_CHANNEL_OPEN:
+                        {
+                            if (data.length < 12) {
+                                log('DATA_CHANNEL_OPEN data.length not enough');
+                                return;
+                            }
+                            if (!Object.keys(this.dataChannels).includes(streamId.toString())) {
+                                // !BBHLHH — 12 byte DCEP OPEN header (big-endian)
+                                const channelType = data.readUInt8(1);
+                                const reliability = data.readUInt32BE(4);
+                                const labelLength = data.readUInt16BE(8);
+                                const protocolLength = data.readUInt16BE(10);
+                                let pos = 12;
+                                const label = data.slice(pos, pos + labelLength).toString('utf8');
+                                pos += labelLength;
+                                const protocol = data
+                                    .slice(pos, pos + protocolLength)
+                                    .toString('utf8');
+                                log('DATA_CHANNEL_OPEN', {
+                                    channelType,
+                                    reliability,
+                                    streamId,
+                                    label,
+                                    protocol
+                                });
+                                const maxRetransmits = (channelType & 0x03) === 1 ? reliability : undefined;
+                                const maxPacketLifeTime = (channelType & 0x03) === 2 ? reliability : undefined;
+                                // # register channel
+                                const parameters = new dataChannel_js_1.RTCDataChannelParameters({
+                                    label,
+                                    ordered: (channelType & 0x80) === 0,
+                                    maxPacketLifeTime,
+                                    maxRetransmits,
+                                    protocol,
+                                    id: streamId
+                                });
+                                const channel = new dataChannel_js_1.RTCDataChannel(this, parameters, false);
+                                channel.isCreatedByRemote = true;
+                                this.dataChannels[streamId] = channel;
+                                this.onDataChannel.execute(channel);
+                                channel.setReadyState('open');
+                            }
+                            else {
+                                log('datachannel already opened', 'retransmit ack');
+                            }
+                            const channel = this.dataChannels[streamId];
+                            const ack = Buffer.allocUnsafe(1);
+                            ack.writeUInt8(const_js_1.DATA_CHANNEL_ACK, 0);
+                            this.dataChannelQueue.push([channel, const_js_1.WEBRTC_DCEP, ack]);
+                            await this.dataChannelFlush();
+                        }
+                        break;
+                    case const_js_1.DATA_CHANNEL_ACK:
+                        {
+                            log('DATA_CHANNEL_ACK', streamId, ppId);
+                            const channel = this.dataChannels[streamId];
+                            if (!channel) {
+                                throw new Error('channel not found');
+                            }
+                            channel.setReadyState('open');
+                        }
+                        break;
+                }
+            }
+            else {
+                const channel = this.dataChannels[streamId];
+                if (channel) {
+                    const msg = (() => {
+                        switch (ppId) {
+                            case const_js_1.WEBRTC_STRING:
+                                return data.toString('utf8');
+                            case const_js_1.WEBRTC_STRING_EMPTY:
+                                return '';
+                            case const_js_1.WEBRTC_BINARY:
+                                return data;
+                            case const_js_1.WEBRTC_BINARY_EMPTY:
+                                return Buffer.from([]);
+                            default:
+                                throw new Error();
+                        }
+                    })();
+                    // Update reception statistics
+                    channel.messagesReceived++;
+                    channel.bytesReceived += data.length;
+                    channel.onMessage.execute(msg);
+                    channel.emit('message', { data: msg });
+                    if (channel.onmessage) {
+                        (0, common_js_1.runDetached)(() => channel.onmessage({ data: msg }), (error) => log('onmessage failed', error));
+                    }
+                }
+            }
+        };
+        this.datachannelSend = (channel, data) => {
+            const size = (0, dataChannel_js_1.getDataChannelMessageSize)(data);
+            this.assertSendableMessageSize(size);
+            channel.addBufferedAmount(size);
+            //An empty message is one zero byte with the PPID of an empty message (RFC 8831 section 6.6)
+            if (size === 0) {
+                this.dataChannelQueue.push([
+                    channel,
+                    typeof data === 'string' ? const_js_1.WEBRTC_STRING_EMPTY : const_js_1.WEBRTC_BINARY_EMPTY,
+                    Buffer.from([0])
+                ]);
+            }
+            else {
+                const userData = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                this.dataChannelQueue.push(typeof data === 'string'
+                    ? [channel, const_js_1.WEBRTC_STRING, userData]
+                    : [channel, const_js_1.WEBRTC_BINARY, userData]);
+            }
+            if (this.sctp.associationState !== index_js_1.SCTP_STATE.ESTABLISHED) {
+                log('sctp not established', this.sctp.associationState);
+            }
+            this.dataChannelFlush().catch((error) => log('flush failed', error));
+            return size;
+        };
+    }
+    get transport() {
+        return this.dtlsTransport;
+    }
+    setDtlsTransport(dtlsTransport) {
+        if (this.dtlsTransport && this.dtlsTransport.id === dtlsTransport.id) {
+            return;
+        }
+        this.eventDisposer.forEach((dispose) => dispose());
+        this.dtlsTransport = dtlsTransport;
+        this.sctp = new index_js_1.SCTP(new BridgeDtls(this.dtlsTransport), this.port, this.sctpOptions);
+        this.eventDisposer = [
+            ...[
+                this.sctp.onReceive.subscribe((0, common_js_1.detached)(this.datachannelReceive, (error) => log('receive failed', error))),
+                this.sctp.onReconfigStreams.subscribe((ids) => {
+                    ids.forEach((id) => {
+                        const dc = this.dataChannels[id];
+                        if (!dc)
+                            return;
+                        // todo fix
+                        dc.setReadyState('closing');
+                        dc.setReadyState('closed');
+                        delete this.dataChannels[id];
+                    });
+                }),
+                this.sctp.stateChanged.connected.subscribe(() => {
+                    Object.values(this.dataChannels).forEach((channel) => {
+                        if (channel.negotiated && channel.readyState !== 'open') {
+                            channel.setReadyState('open');
+                        }
+                    });
+                    this.dataChannelFlush().catch((error) => log('flush failed', error));
+                }),
+                this.sctp.stateChanged.closed.subscribe(() => {
+                    Object.values(this.dataChannels).forEach((dc) => {
+                        dc.setReadyState('closed');
+                    });
+                    this.dataChannels = {};
+                }),
+                this.dtlsTransport.onStateChange.subscribe((state) => {
+                    if (state === 'closed') {
+                        this.sctp.setState(index_js_1.SCTP_STATE.CLOSED);
+                    }
+                })
+            ].map((e) => e.unSubscribe),
+            () => (this.sctp.onSackReceived = async () => { }),
+            () => (this.sctp.onSent = undefined)
+        ];
+        this.sctp.onSackReceived = async () => {
+            await this.dataChannelFlush();
+        };
+        //A message leaves the send buffer of its channel when SCTP sends its chunks (bufferedAmount, W3C WebRTC)
+        this.sctp.onSent = (streamId, ppId, bytes) => {
+            if (ppId === const_js_1.WEBRTC_DCEP ||
+                ppId === const_js_1.WEBRTC_STRING_EMPTY ||
+                ppId === const_js_1.WEBRTC_BINARY_EMPTY) {
+                return;
+            }
+            this.dataChannels[streamId]?.addBufferedAmount(-bytes);
+        };
+    }
+    /**
+     * Keep bytes received out of the receive window while the application holds them (see SCTP.holdReceived)
+     * @param bytes
+     */
+    holdReceived(bytes) {
+        this.sctp.holdReceived(bytes);
+    }
+    /**
+     * Give back bytes held to the receive window (see SCTP.releaseReceived)
+     * @param bytes
+     */
+    releaseReceived(bytes) {
+        this.sctp.releaseReceived(bytes);
+    }
+    get isServer() {
+        return this.dtlsTransport.iceTransport.role !== 'controlling';
+    }
+    channelByLabel(label) {
+        return Object.values(this.dataChannels).find((d) => d.label === label);
+    }
+    dataChannelAddNegotiated(channel) {
+        if (channel.id == undefined) {
+            throw new Error();
+        }
+        if (this.dataChannels[channel.id]) {
+            throw new Error();
+        }
+        this.dataChannels[channel.id] = channel;
+        if (this.sctp.associationState === index_js_1.SCTP_STATE.ESTABLISHED) {
+            channel.setReadyState('open');
+        }
+    }
+    dataChannelOpen(channel) {
+        if (channel.id !== undefined) {
+            if (this.dataChannels[channel.id])
+                throw new Error(`Data channel with ID ${channel.id} already registered`);
+            this.dataChannels[channel.id] = channel;
+        }
+        //The reliability (RFC 8832 section 5.1), and the unordered flag with any of them
+        let channelType = const_js_1.DATA_CHANNEL_RELIABLE;
+        const priority = 0;
+        let reliability = 0;
+        if (channel.maxRetransmits !== null) {
+            channelType = 1;
+            reliability = channel.maxRetransmits;
+        }
+        else if (channel.maxPacketLifeTime !== null) {
+            channelType = 2;
+            reliability = channel.maxPacketLifeTime;
+        }
+        if (!channel.ordered) {
+            channelType |= 0x80;
+        }
+        // 5.1.  DATA_CHANNEL_OPEN Message
+        // !BBHLHH — message type / channel type / priority / reliability / label len / protocol len
+        const data = Buffer.allocUnsafe(12);
+        data.writeUInt8(const_js_1.DATA_CHANNEL_OPEN, 0);
+        data.writeUInt8(channelType, 1);
+        data.writeUInt16BE(priority, 2);
+        data.writeUInt32BE(reliability, 4);
+        //The lengths in bytes, of the UTF-8 label and protocol
+        const label = Buffer.from(channel.label, 'utf8');
+        const protocol = Buffer.from(channel.protocol, 'utf8');
+        data.writeUInt16BE(label.length, 8);
+        data.writeUInt16BE(protocol.length, 10);
+        const send = Buffer.concat([data, label, protocol]);
+        this.dataChannelQueue.push([channel, const_js_1.WEBRTC_DCEP, send]);
+        this.dataChannelFlush().catch((error) => log('flush failed', error));
+    }
+    async dataChannelFlush() {
+        // """
+        // Try to flush buffered data to the SCTP layer.
+        // We wait until the association is established, as we need to know
+        // whether we are a client or a server to correctly assign an odd/even ID
+        // to the data channels.
+        // """
+        if (this.sctp.associationState != index_js_1.SCTP_STATE.ESTABLISHED)
+            return;
+        while (this.dataChannelQueue.length > 0) {
+            const [channel, protocol, userData] = this.dataChannelQueue.shift();
+            let streamId = channel.id;
+            if (streamId === undefined) {
+                streamId = this.dataChannelId;
+                while (Object.keys(this.dataChannels).includes(streamId.toString())) {
+                    streamId += 2;
+                }
+                this.dataChannels[streamId] = channel;
+                channel.setId(streamId);
+            }
+            //Queued in SCTP at once: its windows pace the sending, onSent lowers bufferedAmount
+            if (protocol === const_js_1.WEBRTC_DCEP) {
+                this.sctp
+                    .send(streamId, protocol, userData, {
+                    ordered: true
+                })
+                    .catch((error) => log('send dcep failed', error.message));
+            }
+            else {
+                const expiry = channel.maxPacketLifeTime !== null
+                    ? Date.now() + channel.maxPacketLifeTime / 1000
+                    : undefined;
+                this.sctp
+                    .send(streamId, protocol, userData, {
+                    expiry,
+                    maxRetransmits: channel.maxRetransmits ?? undefined,
+                    ordered: channel.ordered
+                })
+                    .catch((error) => log('send data failed', error.message));
+            }
+        }
+        // Resetting the queue to empty array mitigates this.
+        this.dataChannelQueue = [];
+    }
+    assertSendableMessageSize(size) {
+        if (this.remoteMaxMessageSize !== 0 && size > this.remoteMaxMessageSize) {
+            throw new Error(`max-message-size exceeded: ${size} > ${this.remoteMaxMessageSize}`);
+        }
+    }
+    getCapabilities() {
+        return RTCSctpTransport.getCapabilities(this.maxMessageSize);
+    }
+    static getCapabilities(maxMessageSize = exports.DEFAULT_MAX_MESSAGE_SIZE) {
+        return new RTCSctpCapabilities(maxMessageSize);
+    }
+    setRemoteMaxMessageSize(maxMessageSize) {
+        this.remoteMaxMessageSize = maxMessageSize ?? exports.DEFAULT_MAX_MESSAGE_SIZE;
+    }
+    setRemotePort(port) {
+        this.sctp.setRemotePort(port);
+    }
+    async start(remotePort) {
+        //The DTLS client takes the even stream ids, the server the odd ones (RFC 8832 section 6): the roles of ICE may
+        //be the same way round or not
+        this.dataChannelId = this.dtlsTransport.role === 'server' ? 1 : 0;
+        this.sctp.isServer = this.isServer;
+        await this.sctp.start(remotePort);
+    }
+    async stop() {
+        this.dtlsTransport.dataReceiver = () => { };
+        await this.sctp.stop();
+    }
+    dataChannelClose(channel) {
+        if (!['closing', 'closed'].includes(channel.readyState)) {
+            channel.setReadyState('closing');
+            if (this.sctp.associationState === index_js_1.SCTP_STATE.ESTABLISHED) {
+                // Check if channel.id is already in reconfigQueue to prevent duplicates
+                if (!this.sctp.reconfigQueue.includes(channel.id)) {
+                    this.sctp.reconfigQueue.push(channel.id);
+                }
+                if (this.sctp.reconfigQueue.length === 1) {
+                    this.sctp.transmitReconfigRequest().catch((error) => log('reconfig failed', error));
+                }
+            }
+            else {
+                this.dataChannelQueue = this.dataChannelQueue.filter((queueItem) => queueItem[0].id !== channel.id);
+                // Remove any pending reconfiguration requests for this channel
+                this.sctp.reconfigQueue = this.sctp.reconfigQueue.filter((streamId) => streamId !== channel.id);
+                if (channel.id !== undefined) {
+                    delete this.dataChannels[channel.id];
+                }
+                channel.setReadyState('closed');
+            }
+        }
+    }
+}
+exports.RTCSctpTransport = RTCSctpTransport;
+class RTCSctpCapabilities {
+    constructor(maxMessageSize) {
+        this.maxMessageSize = maxMessageSize;
+    }
+}
+exports.RTCSctpCapabilities = RTCSctpCapabilities;
+class BridgeDtls {
+    constructor(dtls) {
+        this.dtls = dtls;
+        this.send = (data) => {
+            return this.dtls.sendData(data);
+        };
+    }
+    set onData(onData) {
+        this.dtls.dataReceiver = onData;
+    }
+    close() { }
+}

package/dist/cjs/lib/peer/types/domain.d.ts

@@ -0,0 +1,5 @@
+export type Kind = 'audio' | 'video' | 'application' | 'unknown';
+export declare const SignalingStates: readonly ["stable", "have-local-offer", "have-remote-offer", "have-local-pranswer", "have-remote-pranswer", "closed"];
+export type RTCSignalingState = (typeof SignalingStates)[number];
+export declare const ConnectionStates: readonly ["closed", "failed", "disconnected", "new", "connecting", "connected"];
+export type ConnectionState = (typeof ConnectionStates)[number];

package/dist/cjs/lib/peer/types/domain.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionStates = exports.SignalingStates = void 0;
+exports.SignalingStates = [
+    'stable',
+    'have-local-offer',
+    'have-remote-offer',
+    'have-local-pranswer',
+    'have-remote-pranswer',
+    'closed'
+];
+exports.ConnectionStates = [
+    'closed',
+    'failed',
+    'disconnected',
+    'new',
+    'connecting',
+    'connected'
+];

package/dist/cjs/lib/peer/types/util.d.ts

@@ -0,0 +1,2 @@
+export type CallbackWithValue<T> = ((e: T) => void) | ((e: T) => Promise<void>) | null | undefined;
+export type Callback = (() => void) | (() => Promise<void>) | null | undefined;

package/dist/cjs/lib/peer/types/util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/peer/utils.d.ts

@@ -0,0 +1,73 @@
+import { type Address } from './imports/common.js';
+import type { TurnServerOptions } from './imports/ice.js';
+import { type MediaDirection } from './media/rtpTransceiver.js';
+import { MediaStreamTrack } from './media/track.js';
+import type { RTCIceServer } from './peerConnection.js';
+export declare function fingerprint(file: Buffer, hashName: string): any;
+export declare function normalizeFingerprintAlgorithm(algorithm: string): string;
+export declare function normalizeFingerprintValue(value: string): string;
+export declare function isDtls(buf: Buffer): boolean;
+export declare function reverseSimulcastDirection(dir: 'recv' | 'send'): "send" | "recv";
+export declare const andDirection: (a: MediaDirection, b: MediaDirection) => "sendonly" | "sendrecv" | "recvonly" | "inactive";
+export declare function reverseDirection(dir: MediaDirection): MediaDirection;
+export declare const milliTime: () => number;
+export declare const microTime: () => bigint;
+export declare const timestampSeconds: () => number;
+/**
+ * The time now as an NTP timestamp (RFC 5905): 32 bits of seconds since 1900, then 32 bits of fraction of a second
+ */
+export declare const ntpTime: (epochMs?: number) => bigint;
+/**
+ * The abs-send-time header extension of a time: the 6 low bits of the seconds and the 18 high bits of the fraction of
+ * its NTP timestamp, without the bigints of ntpTime() (it is computed for each packet)
+ * @param epochMs The time, in milliseconds since the Unix epoch.
+ */
+export declare const absSendTimeOf: (epochMs: number) => Buffer;
+/**
+ * The time of an NTP timestamp, in milliseconds since the Unix epoch
+ * @param ntp
+ */
+export declare const ntpTimeToEpochMs: (ntp: bigint) => number;
+/**
+ * https://datatracker.ietf.org/doc/html/rfc3550#section-4
+ * @param ntp
+ * @returns 32bit
+ */
+export declare const compactNtp: (ntp: bigint) => number;
+export declare function parseIceServers(iceServers: RTCIceServer[]): {
+    stunServer?: Address;
+    turnServer?: Address;
+    turnUsername?: string;
+    turnPassword?: string;
+    turnTransport?: "udp" | "tcp" | "tls";
+    stunServers: Address[];
+    turnServers: TurnServerOptions[];
+};
+export declare function resolveTurnTransport({ configuredTurnTransport, forceTurnTCP, parsedTurnTransport }: {
+    parsedTurnTransport?: 'udp' | 'tcp' | 'tls';
+    configuredTurnTransport?: 'udp' | 'tcp' | 'tls';
+    forceTurnTCP: boolean;
+}): "tls" | "tcp" | "udp" | undefined;
+/**
+ *
+ * @param signatureHash
+ * @param namedCurveAlgorithm necessary when use ecdsa
+ */
+export declare const createSelfSignedCertificate: (signatureHash: import("./index.js").SignatureHash, _namedCurveAlgorithm?: import("./index.js").NamedCurveAlgorithms) => Promise<{
+    certPem: string;
+    keyPem: string;
+    signatureHash: import("./index.js").SignatureHash;
+}>;
+export declare class MediaStreamTrackFactory {
+    static rtpSource({ port, kind, cb }: {
+        port?: number;
+        kind: 'audio' | 'video';
+        cb?: (buf: Buffer) => Buffer;
+    }): Promise<readonly [MediaStreamTrack, number, () => void]>;
+}
+/**
+ * Merge two objects. If a property value in the source object is undefined or
+ * when casted is equal to undefined (== undefined), then it will not overwrite
+ * the value of the property in the destination object.
+ */
+export declare const deepMerge: <T>(dst: T, src: T) => T;