dsc-itv2-client 1.0.22 → 1.0.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsc-itv2-client",
   "author": "fajitacat",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "Reverse engineered DSC ITV2 Protocol Client Library for TL280R Communicator - Monitor and control DSC alarm panels",
   "main": "src/index.js",
   "type": "module",

package/src/ITV2Client.js

@@ -5,6 +5,7 @@
 
 import {EventEmitter} from 'events';
 import dgram from 'dgram';
+import net from 'net';
 import {ITv2Session, CMD, CMD_NAMES} from './itv2-session.js';
 import {parseType1Initializer, type2InitializerTransform} from './itv2-crypto.js';
 import {EventHandler} from './event-handler.js';
@@ -22,18 +23,23 @@ export class ITV2Client extends EventEmitter {
         this.integrationId = options.integrationId;
         this.accessCode = options.accessCode;
         this.masterCode = options.masterCode || '5555';
-        this.port = options.port || 3073;
+        this.port = options.port || 3073;  // UDP polling port
+        this.tcpPort = options.tcpPort || 3072;  // TCP notification port
         this.logLevel = options.logLevel || (options.debug === true ? 'verbose' : 'minimal'); // 'silent', 'minimal', 'verbose'
         this.encryptionType = options.encryptionType || null; // null = auto-detect, 1 = Type 1, 2 = Type 2
 
         // Internal state
-        this.server = null;
+        this.server = null;  // UDP server
+        this.tcpServer = null;  // TCP server
+        this.tcpClients = new Map();  // Active TCP connections
         this.session = null;
         this.eventHandler = new EventHandler();
         this.handshakeState = 'WAITING';
         this.panelAddress = null;
         this.panelPort = null;
         this.detectedEncryptionType = null; // Set during handshake
+        this._lastTransport = 'udp';  // Track last packet source
+        this._lastTcpSocket = null;  // Track TCP socket for responses
 
         // Bind methods
         this._handlePacket = this._handlePacket.bind(this);
@@ -69,6 +75,9 @@ export class ITV2Client extends EventEmitter {
 
             this.server.bind(this.port, '0.0.0.0');
 
+            // Start TCP server for notification port
+            this._startTcpServer();
+
             // Register signal handlers (only once)
             if (!this._boundShutdown) {
                 this._boundShutdown = async () => {
@@ -81,6 +90,97 @@ export class ITV2Client extends EventEmitter {
         });
     }
 
+    /**
+     * Start TCP server for notification port (3072)
+     */
+    _startTcpServer() {
+        this.tcpServer = net.createServer((socket) => {
+            const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
+            this._logMinimal(`[TCP] Client connected: ${clientId}`);
+            this.tcpClients.set(clientId, socket);
+
+            // Store panel address from TCP connection too
+            if (!this.panelAddress) {
+                this.panelAddress = socket.remoteAddress;
+            }
+
+            let buffer = Buffer.alloc(0);
+
+            socket.on('data', (data) => {
+                this._logMinimal(`[TCP] Received ${data.length} bytes from ${clientId}`);
+                this._logMinimal(`[TCP] Raw data: ${data.toString('hex')}`);
+
+                // Accumulate data in buffer
+                buffer = Buffer.concat([buffer, data]);
+
+                // Try to parse complete packets (look for 0x7E...0x7F framing)
+                this._processTcpBuffer(buffer, socket, (remaining) => {
+                    buffer = remaining;
+                });
+            });
+
+            socket.on('close', () => {
+                this._logMinimal(`[TCP] Client disconnected: ${clientId}`);
+                this.tcpClients.delete(clientId);
+            });
+
+            socket.on('error', (err) => {
+                this._log(`[TCP] Socket error for ${clientId}: ${err.message}`);
+                this.tcpClients.delete(clientId);
+            });
+        });
+
+        this.tcpServer.on('error', (err) => {
+            this._log(`[TCP] Server error: ${err.message}`);
+            this.emit('error', err);
+        });
+
+        this.tcpServer.listen(this.tcpPort, '0.0.0.0', () => {
+            this._logMinimal(`[TCP] Server listening on port ${this.tcpPort}`);
+            this.emit('tcp:listening', { port: this.tcpPort });
+        });
+    }
+
+    /**
+     * Process TCP buffer looking for complete ITV2 packets
+     */
+    _processTcpBuffer(buffer, socket, callback) {
+        // Look for Integration ID prefix followed by 0x7E
+        const idLength = 12; // Integration ID is 12 ASCII chars
+
+        while (buffer.length > idLength + 2) {
+            // Find start marker (0x7E) after integration ID
+            const startIdx = buffer.indexOf(0x7E, idLength - 1);
+            if (startIdx === -1) {
+                // No start marker found, keep last 12 bytes in case ID is split
+                callback(buffer.slice(Math.max(0, buffer.length - idLength)));
+                return;
+            }
+
+            // Find end marker (0x7F)
+            const endIdx = buffer.indexOf(0x7F, startIdx + 1);
+            if (endIdx === -1) {
+                // No end marker yet, wait for more data
+                callback(buffer);
+                return;
+            }
+
+            // Extract complete packet (including ID prefix)
+            const packetStart = Math.max(0, startIdx - idLength);
+            const packet = buffer.slice(packetStart, endIdx + 1);
+
+            this._logMinimal(`[TCP] Complete packet (${packet.length} bytes): ${packet.toString('hex')}`);
+
+            // Process the packet same as UDP
+            this._handlePacket(packet, 'tcp', socket);
+
+            // Continue with remaining buffer
+            buffer = buffer.slice(endIdx + 1);
+        }
+
+        callback(buffer);
+    }
+
     /**
      * Stop the client and close the session gracefully
      */
@@ -105,6 +205,23 @@ export class ITV2Client extends EventEmitter {
             this.server = null;
         }
 
+        // Close TCP server
+        if (this.tcpServer) {
+            // Close all TCP client connections
+            for (const [clientId, socket] of this.tcpClients) {
+                socket.destroy();
+            }
+            this.tcpClients.clear();
+
+            await new Promise((resolve) => {
+                this.tcpServer.close(() => {
+                    this._log('[Shutdown] TCP server closed');
+                    resolve();
+                });
+            });
+            this.tcpServer = null;
+        }
+
         // Clear session and encryption state to prevent stale keys on reconnect
         if (this.session) {
             this.session.disableAes();
@@ -277,19 +394,29 @@ export class ITV2Client extends EventEmitter {
     }
 
     _sendPacket(packet) {
-        if (!this.panelAddress || !this.panelPort) {
-            this._log('[Error] No panel address/port set');
-            return;
-        }
+        // Use the same transport that the last packet came from
+        if (this._lastTransport === 'tcp' && this._lastTcpSocket) {
+            this._log(`\n[TCP] TX (${packet.length} bytes)`);
+            if (this.debug) {
+                this._hexDump(packet);
+            }
+            this._lastTcpSocket.write(packet);
+        } else {
+            // UDP (default)
+            if (!this.panelAddress || !this.panelPort) {
+                this._log('[Error] No panel address/port set');
+                return;
+            }
 
-        this._log(`\n[UDP] TX to ${this.panelAddress}:${this.panelPort} (${packet.length} bytes)`);
-        if (this.debug) {
-            this._hexDump(packet);
+            this._log(`\n[UDP] TX to ${this.panelAddress}:${this.panelPort} (${packet.length} bytes)`);
+            if (this.debug) {
+                this._hexDump(packet);
+            }
+            this.server.send(packet, this.panelPort, this.panelAddress);
         }
-        this.server.send(packet, this.panelPort, this.panelAddress);
     }
 
-    _handlePacket(data) {
+    _handlePacket(data, transport = 'udp', tcpSocket = null) {
         try {
             if (!this.session) {
                 // Create session with appropriate logger based on log level
@@ -304,8 +431,13 @@ export class ITV2Client extends EventEmitter {
                 return;
             }
 
-            // Verbose logging only
-            this._log(`\n[UDP] RX from ${this.panelAddress}:${this.panelPort} (${data.length} bytes)`);
+            // Store transport info for responses
+            this._lastTransport = transport;
+            this._lastTcpSocket = tcpSocket;
+
+            // Verbose logging
+            const source = transport === 'tcp' ? 'TCP' : `UDP ${this.panelAddress}:${this.panelPort}`;
+            this._log(`\n[${transport.toUpperCase()}] RX from ${source} (${data.length} bytes)`);
             this._hexDump(data);
             this._log(`[Packet] Integration ID: ${parsed.integrationId}`);
             this._log(`[Packet] Sender Seq: ${parsed.senderSequence}, Receiver Seq: ${parsed.receiverSequence}`);
@@ -379,9 +511,23 @@ export class ITV2Client extends EventEmitter {
             case CMD.TIME_DATE_BROADCAST:
                 this._handleTimeDateBroadcast(parsed);
                 break;
+            case CMD.ZONE_STATUS:
+                this._handleZoneStatusResponse(parsed);
+                break;
+            case CMD.PARTITION_STATUS:
+                this._handlePartitionStatusResponse(parsed);
+                break;
+            case CMD.GLOBAL_STATUS:
+                this._handleGlobalStatusResponse(parsed);
+                break;
             default:
                 if (this.handshakeState === 'ESTABLISHED') {
-                    this._log(`[Session] Unhandled command ${CMD_NAMES[cmd] || '0x' + cmd?.toString(16)}`);
+                    const cmdHex = cmd ? '0x' + cmd.toString(16).padStart(4, '0') : 'null';
+                    const cmdName = CMD_NAMES[cmd] || 'UNKNOWN';
+                    this._logMinimal(`[Session] Received command ${cmdName} (${cmdHex})`);
+                    if (parsed.commandData && parsed.commandData.length > 0) {
+                        this._logMinimal(`[Session] Data (${parsed.commandData.length} bytes): ${parsed.commandData.toString('hex')}`);
+                    }
                     this._sendPacket(this.session.buildSimpleAck());
                 }
                 break;
@@ -569,10 +715,17 @@ export class ITV2Client extends EventEmitter {
     }
 
     _handleCommandResponse(parsed) {
-        const responseCode = parsed.commandData?.[0] || 0;
+        const data = parsed.commandData;
+        const responseCode = data?.[0] || 0;
         const appSeqAsEcho = parsed.appSequence;
 
-        this._log(`[Handshake] Got COMMAND_RESPONSE (echoed app_seq: ${appSeqAsEcho}, response_code: ${responseCode}), sending ACK`);
+        this._log(`[Session] Got COMMAND_RESPONSE (app_seq: ${appSeqAsEcho}, response_code: ${responseCode})`);
+
+        // Log full data in established state for debugging query responses
+        if (this.handshakeState === 'ESTABLISHED' && data && data.length > 1) {
+            this._logMinimal(`[Command Response] Response code: ${responseCode}, data (${data.length} bytes): ${data.toString('hex')}`);
+            this.emit('command:response', { responseCode, appSequence: appSeqAsEcho, data });
+        }
 
         const ack = this.session.buildSimpleAck();
         this._sendPacket(ack);
@@ -655,6 +808,75 @@ export class ITV2Client extends EventEmitter {
         this._sendPacket(this.session.buildSimpleAck());
     }
 
+    // ==================== Status Query Response Handlers ====================
+
+    _handleZoneStatusResponse(parsed) {
+        const data = parsed.commandData;
+        this._logMinimal(`[Zone Status] Received zone status response`);
+        this._log(`[Zone Status] Raw data (${data?.length || 0} bytes): ${data?.toString('hex') || 'none'}`);
+
+        if (data && data.length >= 3) {
+            // Response format: [ZoneNumber 2B BE][StatusByte 1B][...more zones...]
+            const zoneNum = data.readUInt16BE(0);
+            const statusByte = data[2];
+
+            // Update internal state
+            const fullStatus = this.eventHandler.handleZoneStatus(zoneNum, statusByte);
+
+            this._logMinimal(`[Zone Status] Zone ${zoneNum}: ${fullStatus.open ? 'OPEN' : 'CLOSED'} (0x${statusByte.toString(16)})`);
+
+            // Emit event with full status
+            this.emit('zone:statusResponse', zoneNum, fullStatus);
+            this.emit('zone:status', zoneNum, fullStatus);
+        } else {
+            this._log(`[Zone Status] Empty or invalid response`);
+        }
+
+        this._sendPacket(this.session.buildSimpleAck());
+    }
+
+    _handlePartitionStatusResponse(parsed) {
+        const data = parsed.commandData;
+        this._logMinimal(`[Partition Status] Received partition status response`);
+        this._log(`[Partition Status] Raw data (${data?.length || 0} bytes): ${data?.toString('hex') || 'none'}`);
+
+        if (data && data.length >= 3) {
+            // Response format: [PartitionNumber 2B BE][StatusBytes...]
+            const partitionNum = data.readUInt16BE(0);
+            const statusBytes = data.slice(2);
+
+            this._logMinimal(`[Partition Status] Partition ${partitionNum}: status bytes ${statusBytes.toString('hex')}`);
+
+            // Emit raw event - let consumers parse the detailed status
+            this.emit('partition:statusResponse', partitionNum, statusBytes);
+        } else {
+            this._log(`[Partition Status] Empty or invalid response`);
+        }
+
+        this._sendPacket(this.session.buildSimpleAck());
+    }
+
+    _handleGlobalStatusResponse(parsed) {
+        const data = parsed.commandData;
+        this._logMinimal(`[Global Status] Received global status response`);
+        this._log(`[Global Status] Raw data (${data?.length || 0} bytes): ${data?.toString('hex') || 'none'}`);
+
+        if (data && data.length > 0) {
+            // Emit raw event with full data
+            this.emit('global:statusResponse', data);
+
+            // Log byte breakdown for debugging
+            this._log(`[Global Status] Byte breakdown:`);
+            for (let i = 0; i < data.length && i < 32; i++) {
+                this._log(`  Byte ${i}: 0x${data[i].toString(16).padStart(2, '0')} (${data[i]})`);
+            }
+        } else {
+            this._log(`[Global Status] Empty response`);
+        }
+
+        this._sendPacket(this.session.buildSimpleAck());
+    }
+
     // ==================== Utility Methods ====================
 
     _handleError(error) {