dsc-itv2-client 1.0.23 → 1.0.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsc-itv2-client",
   "author": "fajitacat",
-  "version": "1.0.23",
+  "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}`);