knx.ts 1.0.0

package/dist/connection/TunnelConnection.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelConnection = void 0;
+const KNXnetIPHeader_1 = require("../core/KNXnetIPHeader");
+const KNXnetIPEnum_1 = require("../core/enum/KNXnetIPEnum");
+/**
+ * Encapsulates a single KNXnet/IP Tunnelling or Management connection state.
+ * Handles sequence numbers, heartbeats, reliable delivery (stop-and-wait),
+ * and retransmissions according to KNX Spec Vol 3/8/4.
+ */
+class TunnelConnection {
+    channelId;
+    controlHPAI;
+    dataHPAI;
+    knxAddress;
+    knxAddressStr;
+    knxLayer;
+    socket;
+    heartbeatTimeoutMs;
+    retransmitTimeoutMs;
+    maxQueueSize;
+    onDisconnect;
+    sno = 0;
+    rno = 0;
+    heartbeatTimer = null;
+    pendingAck = null;
+    queue = [];
+    isSending = false;
+    // Rate limiting / Pacing state
+    rxCount = 0;
+    lastRxTime = Date.now();
+    logger;
+    constructor(channelId, controlHPAI, dataHPAI, knxAddress, knxAddressStr, knxLayer, socket, heartbeatTimeoutMs, retransmitTimeoutMs, maxQueueSize, onDisconnect, parentLogger) {
+        this.channelId = channelId;
+        this.controlHPAI = controlHPAI;
+        this.dataHPAI = dataHPAI;
+        this.knxAddress = knxAddress;
+        this.knxAddressStr = knxAddressStr;
+        this.knxLayer = knxLayer;
+        this.socket = socket;
+        this.heartbeatTimeoutMs = heartbeatTimeoutMs;
+        this.retransmitTimeoutMs = retransmitTimeoutMs;
+        this.maxQueueSize = maxQueueSize;
+        this.onDisconnect = onDisconnect;
+        this.logger = parentLogger.child({ channelId, IA: knxAddressStr });
+        this.resetHeartbeat();
+    }
+    /**
+     * Resets the heartbeat timer. Should be called on any valid activity.
+     */
+    resetHeartbeat() {
+        if (this.heartbeatTimer)
+            clearTimeout(this.heartbeatTimer);
+        this.heartbeatTimer = setTimeout(() => {
+            this.logger.warn(`Heartbeat timeout`);
+            this.onDisconnect(this.channelId, true);
+        }, this.heartbeatTimeoutMs);
+    }
+    /**
+     * Enqueues a CEMI message to be sent to the client.
+     */
+    enqueue(cemiBuffer, serviceType) {
+        if (this.maxQueueSize > 0 && this.queue.length >= this.maxQueueSize) {
+            this.logger.warn(`Outgoing queue full. Dropping connection.`);
+            this.onDisconnect(this.channelId, true);
+            return;
+        }
+        const seq = this.sno;
+        const tunnelHeader = Buffer.from([0x04, this.channelId, seq, 0x00]);
+        const responseHeader = new KNXnetIPHeader_1.KNXnetIPHeader(serviceType, KNXnetIPHeader_1.KNXnetIPHeader.HEADER_SIZE_10 + tunnelHeader.length + cemiBuffer.length);
+        const packet = Buffer.concat([responseHeader.toBuffer(), tunnelHeader, cemiBuffer]);
+        this.queue.push({ packet, seq, serviceType });
+        this.sno = (this.sno + 1) % 256;
+        this.processQueue();
+    }
+    processQueue() {
+        if (this.isSending || this.queue.length === 0)
+            return;
+        this.isSending = true;
+        const item = this.queue.shift();
+        this.sendWithRetry(item.packet, item.seq, false);
+    }
+    sendWithRetry(packet, seq, isRetransmission) {
+        if (!this.socket)
+            return;
+        try {
+            this.socket.send(packet, this.dataHPAI.port, this.dataHPAI.ipAddress);
+        }
+        catch (err) {
+            this.logger.error(`Failed to send packet to ${this.dataHPAI.ipAddress}: ${err.message}`);
+            this.onDisconnect(this.channelId, false);
+            return;
+        }
+        this.pendingAck = {
+            packet,
+            seq,
+            isRetransmission,
+            timer: setTimeout(() => {
+                if (!isRetransmission) {
+                    // Spec 2.6.1: Repeat once
+                    this.logger.warn(`ACK timeout for seq ${seq}, retransmitting...`);
+                    this.sendWithRetry(packet, seq, true);
+                }
+                else {
+                    // Spec 2.6.1: Terminate connection
+                    this.logger.error(`Second ACK timeout for seq ${seq}. Terminating connection.`);
+                    this.onDisconnect(this.channelId, true);
+                }
+            }, this.retransmitTimeoutMs)
+        };
+    }
+    /**
+     * Handles an incoming ACK from the client.
+     */
+    handleAck(seq, status) {
+        this.resetHeartbeat();
+        if (this.pendingAck && this.pendingAck.seq === seq) {
+            clearTimeout(this.pendingAck.timer);
+            this.pendingAck = null;
+            this.isSending = false;
+            if (status !== KNXnetIPEnum_1.KNXnetIPErrorCodes.E_NO_ERROR) {
+                this.logger.warn(`Received ACK with error ${status}. Closing connection.`);
+                this.onDisconnect(this.channelId, true);
+                return;
+            }
+            // Process next item in queue
+            this.processQueue();
+        }
+        else {
+            this.logger.debug(`Ignored ACK for seq ${seq} (expected ${this.pendingAck?.seq})`);
+        }
+    }
+    /**
+     * Validates an incoming request from the client according to sequence number rules.
+     */
+    validateRequest(seq) {
+        this.resetHeartbeat();
+        if (seq === this.rno) {
+            // Expected sequence number
+            this.rno = (this.rno + 1) % 256;
+            return { action: 'process', status: KNXnetIPEnum_1.KNXnetIPErrorCodes.E_NO_ERROR };
+        }
+        else if (seq === (this.rno - 1 + 256) % 256) {
+            // Previous sequence number (retransmit ACK)
+            return { action: 'retransmit_ack', status: KNXnetIPEnum_1.KNXnetIPErrorCodes.E_NO_ERROR };
+        }
+        else {
+            // Out of sequence - discard without reply (Spec 2.6.1)
+            this.logger.warn(`Out of sequence request: got ${seq}, expected ${this.rno}`);
+            return { action: 'discard', status: 0 };
+        }
+    }
+    /**
+     * Closes the connection and cleans up resources.
+     */
+    close() {
+        if (this.heartbeatTimer)
+            clearTimeout(this.heartbeatTimer);
+        if (this.pendingAck)
+            clearTimeout(this.pendingAck.timer);
+        this.heartbeatTimer = null;
+        this.pendingAck = null;
+        this.queue = [];
+        this.isSending = false;
+    }
+}
+exports.TunnelConnection = TunnelConnection;