node-rtc-connection 1.0.11 → 1.0.14

package/src/sctp/RTCSctpTransport.js

@@ -0,0 +1,253 @@
+/**
+ * @file RTCSctpTransport.js
+ * @description SCTP transport implementation for WebRTC data channels.
+ * @module sctp/RTCSctpTransport
+ * 
+ * Ported from Chromium's RTCSctpTransport implementation:
+ * - cc/rtc_sctp_transport.h
+ * - cc/rtc_sctp_transport.cc
+ * - cc/rtc_sctp_transport.idl
+ */
+
+const EventEmitter = require('events');
+
+/**
+ * RTCSctpTransportState - Current state of the SCTP transport
+ * @readonly
+ * @enum {string}
+ */
+const RTCSctpTransportState = Object.freeze({
+  CONNECTING: 'connecting',
+  CONNECTED: 'connected',
+  CLOSED: 'closed'
+});
+
+/**
+ * Default SCTP configuration values
+ * @private
+ */
+const SCTP_DEFAULTS = {
+  MAX_MESSAGE_SIZE: 256 * 1024, // 256 KB default
+  MAX_CHANNELS: 65535 // Maximum number of SCTP streams
+};
+
+/**
+ * @class RTCSctpTransport
+ * @extends EventEmitter
+ * @description Represents the SCTP transport layer for WebRTC data channels.
+ * SCTP (Stream Control Transmission Protocol) provides reliable, message-oriented
+ * transport over DTLS for data channels.
+ * 
+ * Events:
+ * - 'statechange': Fired when the transport state changes
+ * 
+ * @example
+ * const sctpTransport = new RTCSctpTransport(dtlsTransport);
+ * sctpTransport.on('statechange', () => {
+ *   console.log('SCTP state:', sctpTransport.state);
+ *   console.log('Max message size:', sctpTransport.maxMessageSize);
+ * });
+ */
+class RTCSctpTransport extends EventEmitter {
+  /**
+   * Create an RTCSctpTransport instance.
+   * @param {RTCDtlsTransport} dtlsTransport - The underlying DTLS transport
+   * @param {Object} [options] - SCTP configuration options
+   * @param {number} [options.maxMessageSize] - Maximum message size in bytes
+   * @param {number} [options.maxChannels] - Maximum number of channels
+   * @throws {TypeError} If dtlsTransport is not provided or invalid
+   */
+  constructor(dtlsTransport, options = {}) {
+    super();
+
+    if (!dtlsTransport || typeof dtlsTransport !== 'object') {
+      throw new TypeError('dtlsTransport is required');
+    }
+
+    // Store the DTLS transport
+    this._dtlsTransport = dtlsTransport;
+    
+    // Internal state
+    this._state = RTCSctpTransportState.CONNECTING;
+    
+    // SCTP configuration
+    // Keep null if explicitly passed, otherwise use default
+    if (options.maxMessageSize === null) {
+      this._maxMessageSize = null;
+    } else {
+      this._maxMessageSize = options.maxMessageSize || SCTP_DEFAULTS.MAX_MESSAGE_SIZE;
+    }
+    this._maxChannels = options.maxChannels !== undefined ? options.maxChannels : SCTP_DEFAULTS.MAX_CHANNELS;
+    
+    // Closed flags
+    this._closed = false;
+    this._closedFromOwner = false;
+    this._startCompleted = false;
+
+    // Listen to DTLS transport state changes
+    this._dtlsTransport.on('statechange', () => {
+      this._onDtlsStateChange();
+    });
+
+    // Start SCTP if DTLS is already connected
+    if (this._dtlsTransport.state === 'connected') {
+      this._start();
+    }
+  }
+
+  /**
+   * Get the underlying DTLS transport.
+   * @returns {RTCDtlsTransport} The DTLS transport
+   */
+  get transport() {
+    return this._dtlsTransport;
+  }
+
+  /**
+   * Get the current SCTP transport state.
+   * @returns {string} The transport state
+   */
+  get state() {
+    if (this._closedFromOwner) {
+      return RTCSctpTransportState.CLOSED;
+    }
+    return this._state;
+  }
+
+  /**
+   * Get the maximum message size in bytes.
+   * This represents the maximum size of data that can be sent in a single message.
+   * 
+   * @returns {number} Maximum message size in bytes, or Infinity if unlimited
+   */
+  get maxMessageSize() {
+    // Return Infinity if explicitly null or undefined (unlimited)
+    if (this._maxMessageSize === null) {
+      return Infinity;
+    }
+    return this._maxMessageSize;
+  }
+
+  /**
+   * Get the maximum number of channels.
+   * This represents the maximum number of data channels that can be opened.
+   * 
+   * @returns {number|null} Maximum number of channels, or null if unknown
+   */
+  get maxChannels() {
+    return this._maxChannels;
+  }
+
+  /**
+   * Start the SCTP association.
+   * Called internally when DTLS is connected.
+   * @private
+   */
+  _start() {
+    if (this._startCompleted || this._closed) {
+      return;
+    }
+
+    this._startCompleted = true;
+
+    // With real network transport, SCTP is handled by the network layer
+    // Transition to connected immediately since we're using raw TCP/UDP
+    setImmediate(() => {
+      if (!this._closed && this._state === RTCSctpTransportState.CONNECTING) {
+        this._setState(RTCSctpTransportState.CONNECTED);
+      }
+    });
+  }
+
+  /**
+   * Close the SCTP transport.
+   * Called by the owning peer connection when it closes.
+   */
+  close() {
+    if (this._closed) {
+      return;
+    }
+
+    this._closedFromOwner = true;
+    this._closed = true;
+    
+    // Emit state change if not already closed
+    if (this._state !== RTCSctpTransportState.CLOSED) {
+      this._state = RTCSctpTransportState.CLOSED;
+      this.emit('statechange');
+    }
+  }
+
+  /**
+   * Internal close method.
+   * @param {string} reason - Reason for closing
+   * @private
+   */
+  _close(reason) {
+    if (this._closed) {
+      return;
+    }
+
+    this._closed = true;
+    this._setState(RTCSctpTransportState.CLOSED);
+  }
+
+  /**
+   * Set the transport state and emit event if changed.
+   * @param {string} newState - The new state
+   * @private
+   */
+  _setState(newState) {
+    if (this._state !== newState) {
+      this._state = newState;
+      this.emit('statechange');
+    }
+  }
+
+  /**
+   * Handle DTLS transport state changes.
+   * @private
+   */
+  _onDtlsStateChange() {
+    const dtlsState = this._dtlsTransport.state;
+    
+    // Start SCTP when DTLS is connected
+    if (dtlsState === 'connected' && !this._startCompleted) {
+      this._start();
+    }
+    
+    // Close SCTP when DTLS closes or fails
+    if (dtlsState === 'closed' || dtlsState === 'failed') {
+      this._close('dtls-closed');
+    }
+  }
+
+  /**
+   * Update SCTP configuration.
+   * @param {Object} info - SCTP transport information
+   * @param {number} [info.maxMessageSize] - Maximum message size
+   * @param {number} [info.maxChannels] - Maximum number of channels
+   * @private
+   */
+  _updateConfiguration(info) {
+    if (info.maxMessageSize !== undefined) {
+      this._maxMessageSize = info.maxMessageSize;
+    }
+    if (info.maxChannels !== undefined) {
+      this._maxChannels = info.maxChannels;
+    }
+  }
+
+  /**
+   * Check if the transport is closed.
+   * @returns {boolean} True if closed, false otherwise
+   */
+  isClosed() {
+    return this._state === RTCSctpTransportState.CLOSED;
+  }
+}
+
+module.exports = {
+  RTCSctpTransport,
+  RTCSctpTransportState
+};

package/src/sdp/RTCSessionDescription.js

@@ -0,0 +1,102 @@
+/**
+ * @file RTCSessionDescription.js
+ * @description Session Description Protocol (SDP) representation
+ * @module sdp/RTCSessionDescription
+ * 
+ * Ported from Chromium's RTCSessionDescription implementation:
+ * - cc/rtc_session_description.idl
+ * - cc/rtc_session_description.h
+ */
+
+'use strict';
+
+/**
+ * RTCSdpType - Types of session descriptions
+ * @readonly
+ * @enum {string}
+ */
+const RTCSdpType = Object.freeze({
+  OFFER: 'offer',
+  PRANSWER: 'pranswer',
+  ANSWER: 'answer',
+  ROLLBACK: 'rollback'
+});
+
+/**
+ * @class RTCSessionDescription
+ * @description Represents a WebRTC session description (offer/answer)
+ * 
+ * @example
+ * const desc = new RTCSessionDescription({
+ *   type: 'offer',
+ *   sdp: 'v=0\r\no=- 123456 2 IN IP4 127.0.0.1\r\n...'
+ * });
+ */
+class RTCSessionDescription {
+  /**
+   * Create an RTCSessionDescription instance.
+   * @param {Object} [init] - Session description init
+   * @param {string} [init.type] - SDP type (offer/answer/pranswer/rollback)
+   * @param {string} [init.sdp] - SDP string
+   */
+  constructor(init = {}) {
+    this._type = init.type || null;
+    this._sdp = init.sdp || null;
+
+    // Validate type if provided
+    if (this._type && !Object.values(RTCSdpType).includes(this._type)) {
+      throw new TypeError(`Invalid SDP type: ${this._type}`);
+    }
+  }
+
+  /**
+   * Get the SDP type.
+   * @returns {string|null} SDP type
+   */
+  get type() {
+    return this._type;
+  }
+
+  /**
+   * Set the SDP type.
+   * @param {string} value - SDP type
+   */
+  set type(value) {
+    if (value && !Object.values(RTCSdpType).includes(value)) {
+      throw new TypeError(`Invalid SDP type: ${value}`);
+    }
+    this._type = value;
+  }
+
+  /**
+   * Get the SDP string.
+   * @returns {string|null} SDP string
+   */
+  get sdp() {
+    return this._sdp;
+  }
+
+  /**
+   * Set the SDP string.
+   * @param {string} value - SDP string
+   */
+  set sdp(value) {
+    this._sdp = value;
+  }
+
+  /**
+   * Convert to JSON representation.
+   * @returns {Object} JSON representation
+   */
+  toJSON() {
+    return {
+      type: this._type,
+      sdp: this._sdp
+    };
+  }
+}
+
+module.exports = {
+  RTCSessionDescription,
+  RTCSdpType
+};

package/src/sdp/sdp-utils.js

@@ -0,0 +1,224 @@
+/**
+ * @file sdp-utils.js
+ * @description SDP parsing and generation utilities
+ * @module sdp/sdp-utils
+ */
+
+'use strict';
+
+/**
+ * Generate a simple SDP offer for data channel only
+ * @param {Object} options - Generation options
+ * @param {string} options.iceUfrag - ICE username fragment
+ * @param {string} options.icePwd - ICE password
+ * @param {Array<Object>} options.fingerprints - DTLS fingerprints
+ * @param {Array<Object>} options.candidates - ICE candidates
+ * @param {string} [options.setup='actpass'] - DTLS setup role
+ * @param {string} [options.connectionAddress] - Connection IP address
+ * @param {number} [options.connectionPort] - Connection port
+ * @returns {string} SDP offer
+ */
+function generateOffer(options) {
+  const {
+    iceUfrag,
+    icePwd,
+    fingerprints = [],
+    candidates = [],
+    setup = 'actpass',
+    connectionAddress = '0.0.0.0',
+    connectionPort = 9
+  } = options;
+
+  const sessionId = Date.now();
+  const sessionVersion = 2;
+  
+  // Get primary fingerprint (SHA-256)
+  const fingerprint = fingerprints.find(fp => fp.algorithm === 'sha-256') || fingerprints[0];
+  
+  let sdp = '';
+  
+  // Session description
+  sdp += 'v=0\r\n';
+  sdp += `o=- ${sessionId} ${sessionVersion} IN IP4 ${connectionAddress}\r\n`;
+  sdp += 's=-\r\n';
+  sdp += 't=0 0\r\n';
+  
+  // Bundle group (data channel only)
+  sdp += 'a=group:BUNDLE 0\r\n';
+  sdp += 'a=msid-semantic: WMS\r\n';
+  
+  // Media description for data channel (application)
+  sdp += `m=application ${connectionPort} UDP/DTLS/SCTP webrtc-datachannel\r\n`;
+  sdp += `c=IN IP4 ${connectionAddress}\r\n`;
+  sdp += 'a=ice-ufrag:' + iceUfrag + '\r\n';
+  sdp += 'a=ice-pwd:' + icePwd + '\r\n';
+  sdp += 'a=ice-options:trickle\r\n';
+  
+  // DTLS fingerprint
+  if (fingerprint) {
+    sdp += `a=fingerprint:${fingerprint.algorithm.toUpperCase()} ${fingerprint.value}\r\n`;
+  }
+  sdp += `a=setup:${setup}\r\n`;
+  
+  // SCTP
+  sdp += 'a=mid:0\r\n';
+  sdp += 'a=sctp-port:5000\r\n';
+  sdp += 'a=max-message-size:262144\r\n';
+  
+  // ICE candidates
+  for (const candidate of candidates) {
+    if (candidate.candidate) {
+      sdp += `a=${candidate.candidate}\r\n`;
+    }
+  }
+  
+  return sdp;
+}
+
+/**
+ * Generate a simple SDP answer for data channel only
+ * @param {Object} options - Generation options
+ * @param {string} options.iceUfrag - ICE username fragment
+ * @param {string} options.icePwd - ICE password
+ * @param {Array<Object>} options.fingerprints - DTLS fingerprints
+ * @param {Array<Object>} options.candidates - ICE candidates
+ * @param {string} [options.setup='active'] - DTLS setup role
+ * @returns {string} SDP answer
+ */
+function generateAnswer(options) {
+  // Answer is similar to offer but with different setup role
+  return generateOffer({
+    ...options,
+    setup: options.setup || 'active'
+  });
+}
+
+/**
+ * Parse SDP string to extract ICE candidates
+ * @param {string} sdp - SDP string
+ * @returns {Array<Object>} Array of candidate objects
+ */
+function parseCandidates(sdp) {
+  const candidates = [];
+  const lines = sdp.split('\r\n');
+  
+  for (const line of lines) {
+    if (line.startsWith('a=candidate:')) {
+      candidates.push({
+        candidate: line,
+        sdpMid: '0',
+        sdpMLineIndex: 0
+      });
+    }
+  }
+  
+  return candidates;
+}
+
+/**
+ * Parse SDP to extract ICE parameters
+ * @param {string} sdp - SDP string
+ * @returns {Object} ICE parameters
+ */
+function parseIceParameters(sdp) {
+  const lines = sdp.split('\r\n');
+  const params = {
+    usernameFragment: null,
+    password: null
+  };
+  
+  for (const line of lines) {
+    if (line.startsWith('a=ice-ufrag:')) {
+      params.usernameFragment = line.substring(12);
+    } else if (line.startsWith('a=ice-pwd:')) {
+      params.password = line.substring(10);
+    }
+  }
+  
+  return params;
+}
+
+/**
+ * Parse SDP to extract DTLS parameters
+ * @param {string} sdp - SDP string
+ * @returns {Object} DTLS parameters
+ */
+function parseDtlsParameters(sdp) {
+  const lines = sdp.split('\r\n');
+  const params = {
+    role: 'auto',
+    fingerprints: []
+  };
+  
+  for (const line of lines) {
+    if (line.startsWith('a=setup:')) {
+      const setup = line.substring(8);
+      if (setup === 'active') params.role = 'client';
+      else if (setup === 'passive') params.role = 'server';
+      else params.role = 'auto';
+    } else if (line.startsWith('a=fingerprint:')) {
+      const parts = line.substring(14).split(' ');
+      if (parts.length === 2) {
+        params.fingerprints.push({
+          algorithm: parts[0].toLowerCase(),
+          value: parts[1]
+        });
+      }
+    }
+  }
+  
+  return params;
+}
+
+/**
+ * Parse SDP to extract SCTP parameters
+ * @param {string} sdp - SDP string
+ * @returns {Object} SCTP parameters
+ */
+function parseSctpParameters(sdp) {
+  const lines = sdp.split('\r\n');
+  const params = {
+    port: 5000,
+    maxMessageSize: 262144
+  };
+  
+  for (const line of lines) {
+    if (line.startsWith('a=sctp-port:')) {
+      params.port = parseInt(line.substring(12), 10);
+    } else if (line.startsWith('a=max-message-size:')) {
+      params.maxMessageSize = parseInt(line.substring(19), 10);
+    }
+  }
+  
+  return params;
+}
+
+/**
+ * Generate random ICE credentials
+ * @returns {Object} ICE credentials
+ */
+function generateIceCredentials() {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  const randomString = (length) => {
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  };
+  
+  return {
+    usernameFragment: randomString(4),
+    password: randomString(24)
+  };
+}
+
+module.exports = {
+  generateOffer,
+  generateAnswer,
+  parseCandidates,
+  parseIceParameters,
+  parseDtlsParameters,
+  parseSctpParameters,
+  generateIceCredentials
+};