node-rtc-connection 1.0.12 → 1.0.14

package/src/NativePeerConnectionFactory.js

@@ -1,1044 +0,0 @@
-const EventEmitter = require('events');
-const net = require('net');
-const dgram = require('dgram');
-const crypto = require('crypto');
-const os = require('os');
-const STUNClient = require('./STUNClient');
-const ICEGatherer = require('./ICEGatherer');
-const { SecureConnection } = require('./SecureConnection');
-const UDPTransport = require('./UDPTransport');
-
-/**
- * NativePeerConnectionFactory creates native peer connection instances.
- * Real implementation using Node.js net package for peer-to-peer communication.
- */
-class NativePeerConnectionFactory {
-  constructor() {
-    this._initialized = false;
-    this._peerConnections = new Set();
-  }
-
-  /**
-   * Initialize the factory
-   */
-  initialize() {
-    if (this._initialized) {
-      return;
-    }
-
-    console.log('[NativePeerConnectionFactory] Initializing with Node.js net package');
-    this._initialized = true;
-  }
-
-  /**
-   * Create a native peer connection
-   * @param {Object} configuration - RTCConfiguration
-   * @returns {NativePeerConnection}
-   */
-  createPeerConnection(configuration) {
-    if (!this._initialized) {
-      this.initialize();
-    }
-
-    const nativePC = new NativePeerConnection(configuration);
-    this._peerConnections.add(nativePC);
-    
-    nativePC.on('close', () => {
-      this._peerConnections.delete(nativePC);
-    });
-
-    return nativePC;
-  }
-
-  /**
-   * Dispose of the factory and all peer connections
-   */
-  dispose() {
-    for (const pc of this._peerConnections) {
-      pc.close();
-    }
-    this._peerConnections.clear();
-    this._initialized = false;
-  }
-}
-
-/**
- * NativePeerConnection - Real implementation using Node.js net package
- * Implements peer-to-peer connection using TCP for data channels
- */
-class NativePeerConnection extends EventEmitter {
-  constructor(configuration) {
-    super();
-    this._configuration = configuration || {};
-    this._signalingState = 0; // stable
-    this._iceConnectionState = 0; // new
-    this._iceGatheringState = 0; // new
-    this._connectionState = 0; // new
-    this._localDescription = null;
-    this._remoteDescription = null;
-    this._dataChannels = new Map();
-    this._closed = false;
-    
-    // Networking components
-    this._server = null;
-    this._socket = null;
-    this._localAddress = null;
-    this._localPort = null;
-    this._remoteAddress = null;
-    this._remotePort = null;
-    this._isOfferer = false;
-    this._iceUsername = this._generateRandomString(8);
-    this._icePassword = this._generateRandomString(24);
-    this._fingerprint = this._generateFingerprint();
-    
-    // New features
-    this._useEncryption = this._configuration.encryption === true; // Disabled by default
-    this._useUDP = this._configuration.transport === 'udp';
-    this._iceGatherer = new ICEGatherer({
-      stunServers: this._extractSTUNServers(this._configuration),
-      turnServers: this._extractTURNServers(this._configuration)
-    });
-    this._secureConnection = null;
-    this._udpTransport = null;
-    this._iceCandidates = [];
-    this._remoteCandidates = [];
-    this._selectedLocalCandidate = null;
-    this._selectedRemoteCandidate = null;
-    
-    console.log('[NativePeerConnection] Created with STUN/ICE/Encryption support');
-    console.log(`  - Encryption: ${this._useEncryption ? 'enabled' : 'disabled (requires valid certs)'}`);
-    console.log(`  - Transport: ${this._useUDP ? 'UDP' : 'TCP'}`);
-  }
-  
-  /**
-   * Extract STUN servers from configuration
-   * @private
-   */
-  _extractSTUNServers(config) {
-    const stunServers = [];
-    
-    if (config.iceServers) {
-      for (const server of config.iceServers) {
-        if (server.urls) {
-          const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
-          for (const url of urls) {
-            if (url.startsWith('stun:')) {
-              stunServers.push(url.replace('stun:', ''));
-            }
-          }
-        }
-      }
-    }
-    
-    return stunServers.length > 0 ? stunServers : undefined;
-  }
-
-  /**
-   * Extract TURN servers from configuration
-   * @private
-   */
-  _extractTURNServers(config) {
-    const turnServers = [];
-    
-    if (config.iceServers) {
-      for (const server of config.iceServers) {
-        if (server.urls) {
-          const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
-          for (const url of urls) {
-            if (url.startsWith('turn:')) {
-              turnServers.push({
-                urls: url,
-                username: server.username,
-                credential: server.credential
-              });
-            }
-          }
-        }
-      }
-    }
-    
-    if (turnServers.length > 0) {
-      console.log(`[NativePeerConnection] Configured ${turnServers.length} TURN server(s)`);
-    }
-    
-    return turnServers;
-  }
-
-  /**
-   * Create an offer
-   * @param {Object} options
-   * @returns {Promise<{type: string, sdp: string}>}
-   */
-  async createOffer(options) {
-    if (this._closed) {
-      throw new Error('PeerConnection is closed');
-    }
-
-    this._isOfferer = true;
-    
-    // Create TCP server to listen for incoming connections
-    await this._createServer();
-    
-    // Generate real SDP with actual network information
-    const sdp = this._generateSDP('offer');
-    return { type: 'offer', sdp };
-  }
-
-  /**
-   * Create an answer
-   * @param {Object} options
-   * @returns {Promise<{type: string, sdp: string}>}
-   */
-  async createAnswer(options) {
-    if (this._closed) {
-      throw new Error('PeerConnection is closed');
-    }
-
-    if (!this._remoteDescription) {
-      throw new Error('No remote description set');
-    }
-
-    this._isOfferer = false;
-    
-    // Create TCP server to listen for incoming connections (if needed)
-    if (!this._server) {
-      await this._createServer();
-    }
-    
-    // Generate real SDP with actual network information
-    const sdp = this._generateSDP('answer');
-    return { type: 'answer', sdp };
-  }
-
-  /**
-   * Set local description
-   * @param {Object} description
-   * @returns {Promise<void>}
-   */
-  async setLocalDescription(description) {
-    if (this._closed) {
-      throw new Error('PeerConnection is closed');
-    }
-
-    this._localDescription = description;
-    
-    // Update signaling state
-    if (description.type === 'offer') {
-      this._signalingState = 1; // have-local-offer
-      this.emit('signalingstatechange', this._signalingState);
-    } else if (description.type === 'answer') {
-      this._signalingState = 0; // stable
-      this.emit('signalingstatechange', this._signalingState);
-      
-      // If we're answerer and have remote description, connect
-      if (!this._isOfferer && this._remoteDescription) {
-        await this._connectToPeer();
-      }
-    }
-
-    // Start real ICE gathering
-    this._startIceGathering();
-  }
-
-  /**
-   * Set remote description
-   * @param {Object} description
-   * @returns {Promise<void>}
-   */
-  async setRemoteDescription(description) {
-    if (this._closed) {
-      throw new Error('PeerConnection is closed');
-    }
-
-    // Parse remote SDP to extract connection information
-    this._parseSDP(description.sdp);
-    this._remoteDescription = description;
-    
-    // Update signaling state
-    if (description.type === 'offer') {
-      this._signalingState = 2; // have-remote-offer
-      this.emit('signalingstatechange', this._signalingState);
-    } else if (description.type === 'answer') {
-      this._signalingState = 0; // stable
-      this.emit('signalingstatechange', this._signalingState);
-      
-      // If we're offerer and have local description, connect
-      if (this._isOfferer && this._localDescription) {
-        await this._connectToPeer();
-      }
-    }
-  }
-
-  /**
-   * Add ICE candidate
-   * @param {Object} candidate
-   * @returns {Promise<void>}
-   */
-  async addIceCandidate(candidate) {
-    if (this._closed) {
-      throw new Error('PeerConnection is closed');
-    }
-
-    if (!candidate || !candidate.candidate) {
-      // null candidate signals end of candidates - try to select best pair
-      if (this._remoteCandidates.length > 0 && !this._selectedRemoteCandidate) {
-        this._selectBestCandidatePair();
-      }
-      return;
-    }
-
-    // Parse ICE candidate
-    const parsed = this._parseIceCandidate(candidate.candidate);
-    if (!parsed) {
-      return;
-    }
-
-    // Store the remote candidate
-    this._remoteCandidates.push(parsed);
-    console.log(`[NativePeerConnection] Added remote ICE candidate (${parsed.type}): ${parsed.ip}:${parsed.port}`);
-
-    // For backward compatibility, set remote address immediately if not set
-    if (!this._remoteAddress) {
-      this._remoteAddress = parsed.ip;
-      this._remotePort = parsed.port;
-      console.log(`[NativePeerConnection] Remote address: ${this._remoteAddress}:${this._remotePort}`);
-    }
-
-    // If we haven't selected a pair yet, try to select now
-    if (!this._selectedRemoteCandidate && this._iceCandidates.length > 0) {
-      this._selectBestCandidatePair();
-    }
-
-    // If we selected a pair and are offerer, connect
-    if (this._selectedRemoteCandidate && this._isOfferer && 
-        this._signalingState === 0 && !this._socket) {
-      await this._connectToPeer();
-    }
-  }
-
-  /**
-   * Parse ICE candidate string
-   * @private
-   */
-  _parseIceCandidate(candidateStr) {
-    const parts = candidateStr.split(' ');
-    if (parts.length < 6) {
-      return null;
-    }
-
-    return {
-      foundation: parts[0].replace('candidate:', ''),
-      component: parts[1],
-      protocol: parts[2],
-      priority: parseInt(parts[3], 10),
-      ip: parts[4],
-      port: parseInt(parts[5], 10),
-      type: parts[7], // typ host/srflx/relay
-      relatedAddress: parts[9] || null,
-      relatedPort: parts[11] ? parseInt(parts[11], 10) : null
-    };
-  }
-
-  /**
-   * Select best candidate pair for connection
-   * Prioritizes: relay > srflx > host
-   * @private
-   */
-  _selectBestCandidatePair() {
-    if (this._remoteCandidates.length === 0 || this._iceCandidates.length === 0) {
-      return;
-    }
-
-    // Priority order: relay > srflx > host
-    const typePriority = { 'relay': 3, 'srflx': 2, 'host': 1 };
-
-    // Find best local candidate
-    let bestLocal = this._iceCandidates[0];
-    for (const candidate of this._iceCandidates) {
-      if (typePriority[candidate.type] > typePriority[bestLocal.type]) {
-        bestLocal = candidate;
-      }
-    }
-
-    // Find best remote candidate
-    let bestRemote = this._remoteCandidates[0];
-    for (const candidate of this._remoteCandidates) {
-      if (typePriority[candidate.type] > typePriority[bestRemote.type]) {
-        bestRemote = candidate;
-      }
-    }
-
-    this._selectedLocalCandidate = bestLocal;
-    this._selectedRemoteCandidate = bestRemote;
-
-    // Update addresses for connection
-    this._localAddress = bestLocal.ip;
-    this._localPort = bestLocal.port;
-    this._remoteAddress = bestRemote.ip;
-    this._remotePort = bestRemote.port;
-
-    console.log(`[NativePeerConnection] Selected candidate pair:`);
-    console.log(`  Local: ${bestLocal.type} ${this._localAddress}:${this._localPort}`);
-    console.log(`  Remote: ${bestRemote.type} ${this._remoteAddress}:${this._remotePort}`);
-  }
-
-  /**
-   * Create a data channel
-   * @param {string} label
-   * @param {Object} options
-   * @returns {NativeDataChannel}
-   */
-  createDataChannel(label, options) {
-    if (this._closed) {
-      throw new Error('PeerConnection is closed');
-    }
-
-    const channel = new NativeDataChannel(label, options, this);
-    this._dataChannels.set(label, channel);
-    
-    // If socket is already connected, open the channel
-    if (this._socket && this._socket.writable) {
-      setTimeout(() => channel._setConnected(this._socket), 0);
-    }
-    
-    // Emit negotiation needed
-    setTimeout(() => {
-      this.emit('negotiationneeded');
-    }, 0);
-
-    return channel;
-  }
-
-  /**
-   * Set configuration
-   * @param {Object} configuration
-   */
-  setConfiguration(configuration) {
-    this._configuration = configuration;
-  }
-
-  /**
-   * Get stats
-   * @returns {Promise<Object>}
-   */
-  async getStats() {
-    return {
-      type: 'peer-connection',
-      timestamp: Date.now(),
-      // Mock stats
-    };
-  }
-
-  /**
-   * Close the peer connection
-   */
-  close() {
-    if (this._closed) {
-      return;
-    }
-
-    this._closed = true;
-    this._signalingState = 5; // closed
-    
-    // Close all data channels
-    for (const [label, channel] of this._dataChannels) {
-      channel.close();
-    }
-    this._dataChannels.clear();
-
-    // Close secure connection
-    if (this._secureConnection) {
-      this._secureConnection.close();
-      this._secureConnection = null;
-    }
-
-    // Close UDP transport
-    if (this._udpTransport) {
-      this._udpTransport.close();
-      this._udpTransport = null;
-    }
-
-    // Close socket
-    if (this._socket) {
-      this._socket.destroy();
-      this._socket = null;
-    }
-
-    // Close server
-    if (this._server) {
-      this._server.close();
-      this._server = null;
-    }
-
-    this.emit('signalingstatechange', this._signalingState);
-    this.emit('close');
-  }
-
-  /**
-   * Create TCP server to listen for incoming connections
-   * @private
-   */
-  async _createServer() {
-    return new Promise((resolve, reject) => {
-      this._server = net.createServer((socket) => {
-        console.log('[NativePeerConnection] Incoming connection accepted');
-        this._handleIncomingConnection(socket);
-      });
-
-      this._server.listen(0, '0.0.0.0', () => {
-        const address = this._server.address();
-        this._localPort = address.port;
-        this._localAddress = this._getLocalIPAddress();
-        console.log(`[NativePeerConnection] Server listening on ${this._localAddress}:${this._localPort}`);
-        resolve();
-      });
-
-      this._server.on('error', (err) => {
-        console.error('[NativePeerConnection] Server error:', err);
-        reject(err);
-      });
-    });
-  }
-
-  /**
-   * Connect to remote peer
-   * @private
-   */
-  async _connectToPeer() {
-    if (!this._remoteAddress || !this._remotePort) {
-      console.log('[NativePeerConnection] Cannot connect: missing remote address');
-      return;
-    }
-
-    if (this._socket) {
-      console.log('[NativePeerConnection] Already connected');
-      return;
-    }
-
-    // Check if we're using relay candidates - if so, skip tie-breaking
-    const usingRelay = this._selectedLocalCandidate?.type === 'relay' || 
-                       this._selectedRemoteCandidate?.type === 'relay';
-
-    if (!usingRelay) {
-      // Tie-breaking: only connect if our port is higher than remote port
-      // This ensures only one peer connects, avoiding the race condition
-      // Note: This only works for direct connections (host/srflx)
-      if (this._localPort < this._remotePort) {
-        console.log(`[NativePeerConnection] Not connecting (local port ${this._localPort} < remote port ${this._remotePort}), waiting for incoming`);
-        return;
-      }
-    }
-
-    console.log(`[NativePeerConnection] Connecting to ${this._remoteAddress}:${this._remotePort}`);
-    if (usingRelay) {
-      console.log(`[NativePeerConnection] Using TURN relay connection`);
-    }
-    
-    this._socket = new net.Socket();
-    
-    this._socket.connect(this._remotePort, this._remoteAddress, async () => {
-      console.log('[NativePeerConnection] Connected to peer');
-      
-      // Apply TLS encryption if enabled
-      if (this._useEncryption) {
-        await this._wrapWithEncryption(false);
-      }
-      
-      this._iceConnectionState = 2; // connected
-      this.emit('iceconnectionstatechange', this._iceConnectionState);
-      
-      // Announce existing data channels to peer and open them
-      setImmediate(() => {
-        for (const [label, channel] of this._dataChannels) {
-          this._sendChannelAnnouncement(label);
-          channel._setConnected(this._getActiveSocket());
-        }
-      });
-    });
-
-    this._setupSocketHandlers(this._socket);
-  }
-
-  /**
-   * Handle incoming connection from peer
-   * @private
-   */
-  async _handleIncomingConnection(socket) {
-    if (this._socket) {
-      console.log('[NativePeerConnection] Connection already exists, closing new one');
-      socket.destroy();
-      return;
-    }
-
-    console.log('[NativePeerConnection] Accepted connection from peer');
-    
-    // Setup handlers BEFORE storing socket to avoid missing early data
-    this._setupSocketHandlers(socket);
-    
-    this._socket = socket;
-    
-    // Apply TLS encryption if enabled
-    if (this._useEncryption) {
-      await this._wrapWithEncryption(true);
-    }
-    
-    this._iceConnectionState = 2; // connected
-    this.emit('iceconnectionstatechange', this._iceConnectionState);
-    
-    // Announce existing data channels to peer
-    setImmediate(() => {
-      for (const [label, channel] of this._dataChannels) {
-        this._sendChannelAnnouncement(label);
-        channel._setConnected(this._getActiveSocket());
-      }
-    });
-  }
-  
-  /**
-   * Wrap socket with TLS encryption
-   * @private
-   */
-  async _wrapWithEncryption(isServer) {
-    try {
-      console.log(`[NativePeerConnection] Enabling TLS encryption (${isServer ? 'server' : 'client'})`);
-      
-      this._secureConnection = new SecureConnection(this._socket, { isServer });
-      await this._secureConnection.wrap();
-      
-      // Update fingerprint with real certificate
-      this._fingerprint = this._secureConnection.getFingerprint();
-      
-      console.log('[NativePeerConnection] TLS encryption enabled');
-    } catch (err) {
-      console.error('[NativePeerConnection] Failed to enable encryption:', err);
-      throw err;
-    }
-  }
-  
-  /**
-   * Get the active socket (secure or plain)
-   * @private
-   */
-  _getActiveSocket() {
-    return this._secureConnection?.secureSocket || this._socket;
-  }
-
-  /**
-   * Setup socket event handlers
-   * @private
-   */
-  _setupSocketHandlers(socket) {
-    socket.on('data', (data) => {
-      this._handleIncomingData(data);
-    });
-
-    socket.on('close', () => {
-      console.log('[NativePeerConnection] Connection closed');
-      this._iceConnectionState = 6; // closed
-      this.emit('iceconnectionstatechange', this._iceConnectionState);
-      
-      // Close all data channels
-      for (const [label, channel] of this._dataChannels) {
-        channel._handleDisconnect();
-      }
-    });
-
-    socket.on('error', (err) => {
-      console.error('[NativePeerConnection] Socket error:', err);
-      this._iceConnectionState = 4; // failed
-      this.emit('iceconnectionstatechange', this._iceConnectionState);
-    });
-  }
-
-  /**
-   * Send channel announcement to peer (empty message to trigger remote channel creation)
-   * @private
-   */
-  _sendChannelAnnouncement(label) {
-    if (!this._socket) {
-      console.log(`[NativePeerConnection] Cannot announce ${label}: no socket`);
-      return;
-    }
-    
-    const labelBuffer = Buffer.from(label, 'utf8');
-    const labelLength = labelBuffer.length;
-    const emptyData = Buffer.alloc(0);
-    
-    // Message format: <length:4><label-length:2><label><data>
-    // length is the number of bytes after the length field
-    const totalLength = 2 + labelLength + emptyData.length;
-    const buffer = Buffer.allocUnsafe(4 + totalLength);
-    
-    buffer.writeUInt32BE(totalLength, 0);
-    buffer.writeUInt16BE(labelLength, 4);
-    labelBuffer.copy(buffer, 6);
-    
-    this._socket.write(buffer);
-    console.log(`[NativePeerConnection] Announced channel: ${label}`);
-  }
-
-  /**
-   * Handle incoming data from socket
-   * @private
-   */
-  _handleIncomingData(data) {
-    try {
-      // Parse message format: <length:4><channel-label-length:2><channel-label><data>
-      let offset = 0;
-      
-      while (offset < data.length) {
-        if (offset + 6 > data.length) break;
-        
-        const totalLength = data.readUInt32BE(offset);
-        const labelLength = data.readUInt16BE(offset + 4);
-        
-        if (offset + 6 + labelLength + (totalLength - 2 - labelLength) > data.length) break;
-        
-        const label = data.toString('utf8', offset + 6, offset + 6 + labelLength);
-        const messageData = data.slice(offset + 6 + labelLength, offset + 6 + totalLength - 2);
-        
-        // Find or create the data channel
-        let channel = this._dataChannels.get(label);
-        if (!channel) {
-          // Create remote data channel
-          console.log(`[NativePeerConnection] Creating remote channel: ${label}`);
-          channel = new NativeDataChannel(label, {}, this);
-          this._dataChannels.set(label, channel);
-          
-          // Emit datachannel event first (before setting connected)
-          this.emit('datachannel', channel);
-          
-          // Then set it as connected after a small delay to allow event handlers to be set up
-          setImmediate(() => {
-            channel._setConnected(this._socket);
-          });
-        }
-        
-        // Deliver the message (if it has data - announcements are empty)
-        if (messageData.length > 0) {
-          channel._handleIncomingMessage(messageData);
-        }
-        
-        offset += 6 + totalLength - 2;
-      }
-    } catch (err) {
-      console.error('[NativePeerConnection] Error parsing incoming data:', err);
-    }
-  }
-
-  /**
-   * Generate real SDP with actual network information
-   * @private
-   */
-  _generateSDP(type) {
-    const sessionId = Date.now();
-    const address = this._localAddress || '0.0.0.0';
-    const port = this._localPort || 9;
-    
-    return `v=0
-o=- ${sessionId} 2 IN IP4 ${address}
-s=-
-t=0 0
-a=group:BUNDLE data
-a=msid-semantic: WMS
-m=application ${port} TCP/DTLS/SCTP webrtc-datachannel
-c=IN IP4 ${address}
-a=ice-ufrag:${this._iceUsername}
-a=ice-pwd:${this._icePassword}
-a=ice-options:trickle
-a=fingerprint:sha-256 ${this._fingerprint}
-a=setup:actpass
-a=mid:data
-a=sctp-port:5000
-a=max-message-size:262144
-`;
-  }
-
-  /**
-   * Parse SDP to extract connection information
-   * @private
-   */
-  _parseSDP(sdp) {
-    const lines = sdp.split('\n');
-    
-    for (const line of lines) {
-      // Parse connection line: c=IN IP4 <address>
-      if (line.startsWith('c=IN IP4 ')) {
-        const address = line.substring(9).trim();
-        if (address !== '0.0.0.0') {
-          this._remoteAddress = address;
-        }
-      }
-      
-      // Parse media line: m=application <port> ...
-      if (line.startsWith('m=application ')) {
-        const parts = line.split(' ');
-        if (parts.length >= 2) {
-          const port = parseInt(parts[1], 10);
-          if (port > 0 && port !== 9) {
-            this._remotePort = port;
-          }
-        }
-      }
-    }
-    
-    console.log(`[NativePeerConnection] Parsed SDP - Remote: ${this._remoteAddress}:${this._remotePort}`);
-  }
-
-  /**
-   * Get local IP address
-   * @private
-   */
-  _getLocalIPAddress() {
-    const interfaces = os.networkInterfaces();
-    
-    // Try to find a non-internal IPv4 address first
-    for (const name of Object.keys(interfaces)) {
-      for (const iface of interfaces[name]) {
-        if (iface.family === 'IPv4' && !iface.internal) {
-          return iface.address;
-        }
-      }
-    }
-    
-    // Fall back to IPv6 if no IPv4 available
-    for (const name of Object.keys(interfaces)) {
-      for (const iface of interfaces[name]) {
-        if (iface.family === 'IPv6' && !iface.internal) {
-          return iface.address;
-        }
-      }
-    }
-    
-    // Fallback to localhost
-    return '127.0.0.1';
-  }
-
-  /**
-   * Start ICE gathering with real network addresses
-   * @private
-   */
-  /**
-   * Start ICE candidate gathering with STUN support
-   * @private
-   */
-  async _startIceGathering() {
-    this._iceGatheringState = 1; // gathering
-    this.emit('icegatheringstatechange', this._iceGatheringState);
-
-    try {
-      // Use real ICE gatherer to get host and srflx candidates
-      const candidates = await this._iceGatherer.gatherCandidates(this._localPort);
-      
-      console.log(`[NativePeerConnection] Gathered ${candidates.length} ICE candidates`);
-      
-      // Emit each candidate
-      for (const candidate of candidates) {
-        // Parse and store the candidate
-        const parsed = this._parseIceCandidate(candidate.candidate);
-        if (parsed) {
-          this._iceCandidates.push(parsed);
-        }
-
-        this.emit('icecandidate', {
-          candidate: candidate.candidate,
-          sdpMid: candidate.sdpMid,
-          sdpMLineIndex: candidate.sdpMLineIndex
-        });
-        
-        console.log(`[NativePeerConnection] ICE candidate (${candidate.type}): ${candidate.ip}:${candidate.port}`);
-      }
-    } catch (err) {
-      console.warn('[NativePeerConnection] ICE gathering error:', err.message);
-      
-      // Fallback: emit only local host candidate
-      if (this._localAddress && this._localPort) {
-        const candidateStr = `candidate:1 1 tcp 2130706431 ${this._localAddress} ${this._localPort} typ host`;
-        const parsed = this._parseIceCandidate(candidateStr);
-        if (parsed) {
-          this._iceCandidates.push(parsed);
-        }
-
-        const candidate = {
-          candidate: candidateStr,
-          sdpMid: 'data',
-          sdpMLineIndex: 0
-        };
-        this.emit('icecandidate', candidate);
-        console.log(`[NativePeerConnection] Fallback ICE candidate: ${this._localAddress}:${this._localPort}`);
-      }
-    } finally {
-      // Complete gathering
-      setTimeout(() => {
-        this._iceGatheringState = 2; // complete
-        this.emit('icegatheringstatechange', this._iceGatheringState);
-        this.emit('icecandidate', null); // End of candidates
-        console.log('[NativePeerConnection] ICE gathering complete');
-      }, 100);
-    }
-  }
-
-  /**
-   * Generate random string
-   * @private
-   */
-  _generateRandomString(length) {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < length; i++) {
-      result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-  }
-
-  /**
-   * Generate fingerprint
-   * @private
-   */
-  _generateFingerprint() {
-    const bytes = [];
-    for (let i = 0; i < 32; i++) {
-      bytes.push(Math.floor(Math.random() * 256).toString(16).padStart(2, '0').toUpperCase());
-    }
-    return bytes.join(':');
-  }
-}
-
-/**
- * NativeDataChannel - Real implementation using TCP socket
- */
-class NativeDataChannel extends EventEmitter {
-  constructor(label, options = {}, peerConnection) {
-    super();
-    this.label = label;
-    this.ordered = options.ordered !== undefined ? options.ordered : true;
-    this.maxPacketLifeTime = options.maxPacketLifeTime || -1;
-    this.maxRetransmits = options.maxRetransmits || -1;
-    this.protocol = options.protocol || '';
-    this.negotiated = options.negotiated || false;
-    this.id = options.id !== undefined ? options.id : -1;
-    
-    this._state = 0; // connecting
-    this._bufferedAmount = 0;
-    this._closed = false;
-    this._socket = null;
-    this._peerConnection = peerConnection;
-
-    console.log(`[NativeDataChannel] Created: ${label}`);
-  }
-
-  /**
-   * Set socket connection for this channel
-   * @private
-   */
-  _setConnected(socket) {
-    if (this._closed) {
-      return;
-    }
-
-    this._socket = socket;
-    this._state = 1; // open
-    this.emit('statechange', this._state);
-    console.log(`[NativeDataChannel] ${this.label} - Channel opened`);
-  }
-
-  /**
-   * Handle incoming message for this channel
-   * @private
-   */
-  _handleIncomingMessage(data) {
-    if (this._state !== 1) {
-      return;
-    }
-
-    // Check if data is binary or text
-    let binary = true;
-    try {
-      // Try to detect if it's valid UTF-8 text
-      const text = data.toString('utf8');
-      if (text.length > 0 && /^[\x20-\x7E\s]*$/.test(text)) {
-        binary = false;
-      }
-    } catch (e) {
-      binary = true;
-    }
-
-    this.emit('message', { data, binary });
-  }
-
-  /**
-   * Handle socket disconnect
-   * @private
-   */
-  _handleDisconnect() {
-    if (this._closed) {
-      return;
-    }
-
-    this._socket = null;
-    this._state = 3; // closed
-    this.emit('statechange', this._state);
-  }
-
-  /**
-   * Send data over the channel
-   * @param {Object} dataBuffer - { data: Buffer, binary: boolean }
-   */
-  send(dataBuffer) {
-    if (this._state !== 1) {
-      throw new Error('DataChannel is not open');
-    }
-
-    if (!this._socket || !this._socket.writable) {
-      throw new Error('Socket is not writable');
-    }
-
-    try {
-      const data = dataBuffer.data;
-      const labelBuffer = Buffer.from(this.label, 'utf8');
-      
-      // Message format: <length:4><label-length:2><label><data>
-      // Length includes label-length field + label + data
-      const totalLength = 2 + labelBuffer.length + data.length;
-      const header = Buffer.allocUnsafe(6);
-      header.writeUInt32BE(totalLength, 0);
-      header.writeUInt16BE(labelBuffer.length, 4);
-      
-      const message = Buffer.concat([header, labelBuffer, data]);
-      
-      this._bufferedAmount += message.length;
-      this._socket.write(message, () => {
-        this._bufferedAmount = Math.max(0, this._bufferedAmount - message.length);
-        if (this._bufferedAmount === 0) {
-          this.emit('bufferedamountlow', 0);
-        }
-      });
-      
-      console.log(`[NativeDataChannel] ${this.label} - Sent ${data.length} bytes`);
-    } catch (err) {
-      console.error(`[NativeDataChannel] ${this.label} - Send error:`, err);
-      throw err;
-    }
-  }
-
-  /**
-   * Close the channel
-   */
-  close() {
-    if (this._closed) {
-      return;
-    }
-
-    this._closed = true;
-    this._state = 2; // closing
-    this.emit('statechange', this._state);
-
-    setTimeout(() => {
-      this._state = 3; // closed
-      this._socket = null;
-      this.emit('statechange', this._state);
-    }, 10);
-  }
-}
-
-module.exports = NativePeerConnectionFactory;