node-rtc-connection 1.0.18 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-rtc-connection",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "WebRTC DataChannel implementation for Node.js with STUN, TURN, NAT traversal, and encryption. Pure Node.js, no native dependencies.",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",

package/src/ice/RTCIceTransport.js

@@ -357,7 +357,10 @@ class RTCIceTransport extends EventEmitter {
 
     // Validate that candidate has required properties for connectivity checks
     if (!parsedCandidate.address || parsedCandidate.port === null || parsedCandidate.port === undefined) {
-      console.warn('Remote candidate missing address or port, skipping connectivity checks');
+      // Only warn if it's not an empty candidate (which signals end-of-candidates)
+      if (parsedCandidate.candidate !== '') {
+        console.warn('Remote candidate missing address or port, skipping connectivity checks');
+      }
       // Store the original candidate for compatibility
       this._remoteCandidates.push(candidate);
       return;
@@ -684,6 +687,11 @@ class RTCIceTransport extends EventEmitter {
           // Store TURN client as the "socket" for this relay candidate
           this._sockets.set(foundation, { type: 'turn', client: turnClient });
 
+          // Handle incoming data from TURN
+          turnClient.on('data', (data, peer) => {
+            this._handleSocketMessage(data, peer, candidate);
+          });
+
           this._addLocalCandidate(candidate);
 
           // Keep allocation alive
@@ -760,8 +768,8 @@ class RTCIceTransport extends EventEmitter {
    */
   _sendConnectivityCheck(pair) {
     const socket = this._sockets.get(pair.local.foundation);
-    if (!socket || socket.type === 'turn') {
-      return; // Skip TURN candidates for now
+    if (!socket) {
+      return;
     }
 
     // Validate remote candidate has required properties
@@ -778,11 +786,23 @@ class RTCIceTransport extends EventEmitter {
     const request = this._createBindingRequest(transactionId);
     
     try {
-      socket.send(request, pair.remote.port, pair.remote.address, (err) => {
-        if (err) {
-          console.error(`Connectivity check failed for ${pair.remote.address}:${pair.remote.port}:`, err);
-        }
-      });
+      if (socket.type === 'turn') {
+        const turnClient = socket.client;
+        // Create permission and send indication
+        turnClient.createPermission(pair.remote.address)
+          .then(() => {
+            return turnClient.sendIndication(pair.remote.address, pair.remote.port, request);
+          })
+          .catch(err => {
+            // Suppress errors for now as this happens frequently during connection
+          });
+      } else {
+        socket.send(request, pair.remote.port, pair.remote.address, (err) => {
+          if (err) {
+            console.error(`Connectivity check failed for ${pair.remote.address}:${pair.remote.port}:`, err);
+          }
+        });
+      }
     } catch (err) {
       console.error(`Error sending connectivity check to ${pair.remote.address || 'unknown'}:${pair.remote.port || 'unknown'}:`, err);
     }

package/src/peerconnection/RTCPeerConnection.js

@@ -602,6 +602,11 @@ class RTCPeerConnection extends EventEmitter {
       console.error('Failed to establish network connection:', error);
     }
 
+    // Snapshot the candidates BEFORE starting ICE to avoid race condition
+    // If addIceCandidate runs while start() is yielding, it will see transport running and add the candidate.
+    // If we snapshot after start(), we might add the same candidate twice.
+    const candidatesToAdd = [...this._remoteIceCandidates];
+
     // Start ICE
     if (iceParams.usernameFragment && iceParams.password) {
       try {
@@ -612,7 +617,7 @@ class RTCPeerConnection extends EventEmitter {
     }
 
     // Add remote candidates
-    for (const candidate of this._remoteIceCandidates) {
+    for (const candidate of candidatesToAdd) {
       try {
         // Parse candidate string (simplified)
         await this._iceTransport.addRemoteCandidate(candidate);
@@ -672,7 +677,7 @@ class RTCPeerConnection extends EventEmitter {
       throw new Error('RTCPeerConnection is closed');
     }
 
-    if (!candidate) {
+    if (!candidate || (candidate.candidate === '')) {
       // End of candidates signal
       this._iceGatheringState = RTCIceGatheringState.COMPLETE;
       this.emit('icegatheringstatechange');
@@ -685,7 +690,26 @@ class RTCPeerConnection extends EventEmitter {
       this._remoteIceCandidates.push(candidate);
       
       // If connection is already started, add candidate immediately
-      if (this._remoteDescription) {
+      // Check if transport is actually started (not just initialized)
+      // We can infer this if we have remote description AND the transport state is not 'new'
+      // Or simply try/catch and ignore "not started" error, but better to check.
+      // Since we don't have public access to _started, we rely on state.
+      // However, state might be 'new' but start() was called? No, start() sets state to checking.
+      
+      // Actually, _startConnection calls start().
+      // If we are Answerer, we set remote offer. _startConnection is NOT called yet.
+      // It is called when we set local answer.
+      // So we should NOT add candidates yet.
+      
+      // If we are Offerer, we set remote answer. _startConnection IS called.
+      
+      // So we should only add if we have both descriptions (Stable state)?
+      // Or if the transport is started.
+      
+      // Let's check if we are in a state where transport should be running.
+      const isTransportRunning = this._iceTransport.state !== 'new' && this._iceTransport.state !== 'closed';
+      
+      if (isTransportRunning) {
         try {
           await this._iceTransport.addRemoteCandidate(candidate);
         } catch (error) {

package/src/sdp/sdp-utils.js

@@ -105,7 +105,7 @@ function parseCandidates(sdp) {
   for (const line of lines) {
     if (line.startsWith('a=candidate:')) {
       candidates.push({
-        candidate: line,
+        candidate: line.substring(2),
         sdpMid: '0',
         sdpMLineIndex: 0
       });

package/src/stun/stun-client.js

@@ -12,6 +12,8 @@
 const dgram = require('dgram');
 const crypto = require('crypto');
 
+const EventEmitter = require('events');
+
 /**
  * STUN message types
  */
@@ -69,7 +71,7 @@ const MAGIC_COOKIE = 0x2112A442;
  * @class STUNClient
  * @description STUN/TURN client for NAT traversal
  */
-class STUNClient {
+class STUNClient extends EventEmitter {
   /**
    * Create a STUN client
    * @param {Object} options - Client options
@@ -81,6 +83,7 @@ class STUNClient {
    * @param {Object} [options.params={}] - Additional query parameters from URL
    */
   constructor(options) {
+    super();
     this.server = options.server;
     this.port = options.port;
     this.username = options.username;
@@ -204,6 +207,46 @@ class STUNClient {
     return this._sendRequest(request, transactionId, 'refresh');
   }
 
+  /**
+   * Create a TURN Permission for a peer
+   * @param {string} peerAddress - Peer IP address
+   * @returns {Promise<void>}
+   */
+  async createPermission(peerAddress) {
+    if (!this.username || !this.credential) {
+      throw new Error('TURN requires username and credential');
+    }
+
+    const transactionId = crypto.randomBytes(12);
+    const request = this._createCreatePermissionRequest(transactionId, peerAddress);
+
+    await this._sendRequest(request, transactionId, 'createPermission');
+  }
+
+  /**
+   * Send data to a peer via TURN Send Indication
+   * @param {string} peerAddress - Peer IP address
+   * @param {number} peerPort - Peer port
+   * @param {Buffer} data - Data to send
+   * @returns {Promise<void>}
+   */
+  async sendIndication(peerAddress, peerPort, data) {
+    if (!this.username || !this.credential) {
+      throw new Error('TURN requires username and credential');
+    }
+
+    const transactionId = crypto.randomBytes(12);
+    const indication = this._createSendIndication(transactionId, peerAddress, peerPort, data);
+
+    // Indications are fire-and-forget, no response expected
+    return new Promise((resolve, reject) => {
+      this.socket.send(indication, this.port, this.server, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+
   /**
    * Send a TURN request
    * @param {Buffer} request - Request message
@@ -307,6 +350,87 @@ class STUNClient {
     return this._createMessage(STUN_MESSAGE_TYPES.ALLOCATE_REQUEST, transactionId, attributes, withAuth);
   }
 
+  /**
+   * Create a TURN CreatePermission Request
+   * @param {Buffer} transactionId - Transaction ID
+   * @param {string} peerAddress - Peer IP address
+   * @returns {Buffer} STUN message
+   * @private
+   */
+  _createCreatePermissionRequest(transactionId, peerAddress) {
+    const attributes = [];
+
+    // XOR-PEER-ADDRESS
+    const peerAttr = this._createXorPeerAddressAttribute(peerAddress, 0, transactionId);
+    attributes.push(peerAttr);
+
+    // Auth attributes
+    if (this.realm && this.nonce) {
+      attributes.push(this._createStringAttribute(STUN_ATTRIBUTES.USERNAME, this.username));
+      attributes.push(this._createStringAttribute(STUN_ATTRIBUTES.REALM, this.realm));
+      attributes.push(this._createStringAttribute(STUN_ATTRIBUTES.NONCE, this.nonce));
+    }
+
+    return this._createMessage(STUN_MESSAGE_TYPES.CREATE_PERMISSION_REQUEST, transactionId, attributes, true);
+  }
+
+  /**
+   * Create a TURN Send Indication
+   * @param {Buffer} transactionId - Transaction ID
+   * @param {string} peerAddress - Peer IP address
+   * @param {number} peerPort - Peer port
+   * @param {Buffer} data - Data to send
+   * @returns {Buffer} STUN message
+   * @private
+   */
+  _createSendIndication(transactionId, peerAddress, peerPort, data) {
+    const attributes = [];
+
+    // XOR-PEER-ADDRESS
+    const peerAttr = this._createXorPeerAddressAttribute(peerAddress, peerPort, transactionId);
+    attributes.push(peerAttr);
+
+    // DATA
+    const dataAttr = Buffer.alloc(4 + data.length + (4 - (data.length % 4)) % 4);
+    dataAttr.writeUInt16BE(STUN_ATTRIBUTES.DATA, 0);
+    dataAttr.writeUInt16BE(data.length, 2);
+    data.copy(dataAttr, 4);
+    attributes.push(dataAttr);
+
+    return this._createMessage(STUN_MESSAGE_TYPES.SEND_INDICATION, transactionId, attributes, false);
+  }
+
+  /**
+   * Create XOR-PEER-ADDRESS attribute
+   * @param {string} address - IP address
+   * @param {number} port - Port
+   * @param {Buffer} transactionId - Transaction ID
+   * @returns {Buffer} Attribute buffer
+   * @private
+   */
+  _createXorPeerAddressAttribute(address, port, transactionId) {
+    const family = 0x01; // IPv4
+    const buffer = Buffer.alloc(4 + 8); // Type(2) + Length(2) + Reserved(1) + Family(1) + Port(2) + Address(4)
+    
+    buffer.writeUInt16BE(STUN_ATTRIBUTES.XOR_PEER_ADDRESS, 0);
+    buffer.writeUInt16BE(8, 2);
+    buffer.writeUInt8(0, 4);
+    buffer.writeUInt8(family, 5);
+
+    // XOR Port
+    const xorPort = port ^ (MAGIC_COOKIE >> 16);
+    buffer.writeUInt16BE(xorPort, 6);
+
+    // XOR Address
+    const parts = address.split('.').map(Number);
+    const addrInt = (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3];
+    const xorAddr = addrInt ^ MAGIC_COOKIE;
+    
+    buffer.writeUInt32BE(xorAddr >>> 0, 8); // Ensure unsigned
+
+    return buffer;
+  }
+
   /**
    * Create a TURN Refresh Request
    * @param {Buffer} transactionId - Transaction ID
@@ -483,6 +607,16 @@ class STUNClient {
       });
       this.transactions.delete(transactionKey);
     }
+    // Handle Data Indication
+    else if (messageType === STUN_MESSAGE_TYPES.DATA_INDICATION) {
+      if (attributes.xorPeerAddress && attributes.data) {
+        this.emit('data', attributes.data, {
+          address: attributes.xorPeerAddress.address,
+          port: attributes.xorPeerAddress.port,
+          family: attributes.xorPeerAddress.family || 'IPv4'
+        });
+      }
+    }
     // Handle error responses
     else if (messageType === STUN_MESSAGE_TYPES.BINDING_ERROR_RESPONSE ||
              messageType === STUN_MESSAGE_TYPES.ALLOCATE_ERROR_RESPONSE) {