node-rtc-connection 1.0.17 → 1.0.19

package/dist/index.mjs

@@ -813,6 +813,8 @@ function requireStunClient () {
 	const dgram = require$$0;
 	const crypto = require$$3;
 
+	const EventEmitter = require$$0$1;
+
 	/**
 	 * STUN message types
 	 */
@@ -827,7 +829,12 @@ function requireStunClient () {
 	  ALLOCATE_ERROR_RESPONSE: 0x0113,
 	  
 	  REFRESH_REQUEST: 0x0004,
-	  REFRESH_RESPONSE: 0x0104};
+	  REFRESH_RESPONSE: 0x0104,
+	  
+	  SEND_INDICATION: 0x0016,
+	  DATA_INDICATION: 0x0017,
+	  
+	  CREATE_PERMISSION_REQUEST: 0x0008};
 
 	/**
 	 * STUN attribute types
@@ -842,6 +849,8 @@ function requireStunClient () {
 	  XOR_MAPPED_ADDRESS: 0x0020,
 	  
 	  LIFETIME: 0x000D,
+	  XOR_PEER_ADDRESS: 0x0012,
+	  DATA: 0x0013,
 	  XOR_RELAYED_ADDRESS: 0x0016,
 	  REQUESTED_TRANSPORT: 0x0019};
 
@@ -851,7 +860,7 @@ function requireStunClient () {
 	 * @class STUNClient
 	 * @description STUN/TURN client for NAT traversal
 	 */
-	class STUNClient {
+	class STUNClient extends EventEmitter {
 	  /**
 	   * Create a STUN client
 	   * @param {Object} options - Client options
@@ -863,6 +872,7 @@ function requireStunClient () {
 	   * @param {Object} [options.params={}] - Additional query parameters from URL
 	   */
 	  constructor(options) {
+	    super();
 	    this.server = options.server;
 	    this.port = options.port;
 	    this.username = options.username;
@@ -986,6 +996,46 @@ function requireStunClient () {
 	    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
@@ -1089,6 +1139,87 @@ function requireStunClient () {
 	    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
@@ -1265,6 +1396,16 @@ function requireStunClient () {
 	      });
 	      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) {
@@ -1791,7 +1932,10 @@ function requireRTCIceTransport () {
 
 	    // 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;
@@ -2118,6 +2262,11 @@ function requireRTCIceTransport () {
 	          // 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
@@ -2194,8 +2343,8 @@ function requireRTCIceTransport () {
 	   */
 	  _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
@@ -2212,11 +2361,23 @@ function requireRTCIceTransport () {
 	    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);
 	    }
@@ -3855,7 +4016,7 @@ function requireSdpUtils () {
 	  for (const line of lines) {
 	    if (line.startsWith('a=candidate:')) {
 	      candidates.push({
-	        candidate: line,
+	        candidate: line.substring(2),
 	        sdpMid: '0',
 	        sdpMLineIndex: 0
 	      });
@@ -4693,6 +4854,16 @@ function requireRTCPeerConnection () {
 	   * @private
 	   */
 	  _openDataChannels() {
+	    // Check if network transport has active connections
+	    const hasConnections = this._networkTransport && 
+	                          this._networkTransport.tcpTransport && 
+	                          this._networkTransport.tcpTransport.connections.size > 0;
+	    
+	    if (!hasConnections) {
+	      // Network not ready yet, channels will be opened when connection establishes
+	      return;
+	    }
+
 	    for (const channel of this._dataChannels.values()) {
 	      if (channel.readyState === 'connecting') {
 	        this._connectChannelToNetwork(channel);
@@ -5060,6 +5231,11 @@ function requireRTCPeerConnection () {
 	      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 {
@@ -5070,7 +5246,7 @@ function requireRTCPeerConnection () {
 	    }
 
 	    // Add remote candidates
-	    for (const candidate of this._remoteIceCandidates) {
+	    for (const candidate of candidatesToAdd) {
 	      try {
 	        // Parse candidate string (simplified)
 	        await this._iceTransport.addRemoteCandidate(candidate);
@@ -5082,15 +5258,8 @@ function requireRTCPeerConnection () {
 	    // Open data channels when connection is established
 	    this._sctpTransport.once('statechange', () => {
 	      if (this._sctpTransport.state === 'connected') {
-	        for (const channel of this._dataChannels.values()) {
-	          if (channel.readyState === 'connecting') {
-	            // Hook up channel to network transport first
-	            this._connectChannelToNetwork(channel);
-	            
-	            // Then set state to open (emits 'open' event)
-	            channel._setStateToOpen();
-	          }
-	        }
+	        // Wait for network to be ready before opening channels
+	        this._openDataChannels();
 	      }
 	    });
 	  }
@@ -5137,7 +5306,7 @@ function requireRTCPeerConnection () {
 	      throw new Error('RTCPeerConnection is closed');
 	    }
 
-	    if (!candidate) {
+	    if (!candidate || (candidate.candidate === '')) {
 	      // End of candidates signal
 	      this._iceGatheringState = RTCIceGatheringState.COMPLETE;
 	      this.emit('icegatheringstatechange');
@@ -5150,7 +5319,26 @@ function requireRTCPeerConnection () {
 	      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) {
@@ -5317,7 +5505,7 @@ function requireRTCPeerConnection () {
 	return RTCPeerConnection_1;
 }
 
-var version = "1.0.17";
+var version = "1.0.19";
 var require$$10 = {
 	version: version};