@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/scada-server/lib/modbus-server.js

@@ -0,0 +1,492 @@
+"use strict";
+
+
+const net = require("net");
+
+
+function normalizeIp(address) {
+
+    const raw = String(address || "").trim();
+
+    if (!raw) {
+        return null;
+    }
+
+    if (raw.startsWith("::ffff:")) {
+        return raw.slice(7);
+    }
+
+    return raw;
+
+}
+
+
+function notify(options, key, payload) {
+
+    if (typeof options[key] === "function") {
+        options[key](payload);
+    }
+
+}
+
+
+function exceptionResponse(transactionId, unitId, functionCode, exceptionCode) {
+
+    const pdu = Buffer.from([functionCode | 0x80, exceptionCode]);
+
+    const response = Buffer.allocUnsafe(7 + pdu.length);
+
+    response.writeUInt16BE(transactionId, 0);
+
+    response.writeUInt16BE(0, 2);
+
+    response.writeUInt16BE(pdu.length + 1, 4);
+
+    response.writeUInt8(unitId, 6);
+
+    pdu.copy(response, 7);
+
+    return response;
+
+}
+
+
+function registerResponse(transactionId, unitId, functionCode, words) {
+
+    const byteCount = words.length * 2;
+
+    const pdu = Buffer.allocUnsafe(2 + byteCount);
+
+    pdu.writeUInt8(functionCode & 0xFF, 0);
+
+    pdu.writeUInt8(byteCount, 1);
+
+
+    words.forEach(function (word, index) {
+
+        pdu.writeUInt16BE(word & 0xFFFF, 2 + (index * 2));
+
+    });
+
+
+    const response = Buffer.allocUnsafe(7 + pdu.length);
+
+    response.writeUInt16BE(transactionId, 0);
+
+    response.writeUInt16BE(0, 2);
+
+    response.writeUInt16BE(pdu.length + 1, 4);
+
+    response.writeUInt8(unitId, 6);
+
+    pdu.copy(response, 7);
+
+    return response;
+
+}
+
+
+function writeSingleRegisterResponse(transactionId, unitId, address, value) {
+
+    const pdu = Buffer.allocUnsafe(5);
+
+    pdu.writeUInt8(6, 0);
+
+    pdu.writeUInt16BE(address & 0xFFFF, 1);
+
+    pdu.writeUInt16BE(value & 0xFFFF, 3);
+
+
+    const response = Buffer.allocUnsafe(7 + pdu.length);
+
+    response.writeUInt16BE(transactionId, 0);
+
+    response.writeUInt16BE(0, 2);
+
+    response.writeUInt16BE(pdu.length + 1, 4);
+
+    response.writeUInt8(unitId, 6);
+
+    pdu.copy(response, 7);
+
+    return response;
+
+}
+
+
+function writeMultipleRegistersResponse(transactionId, unitId, startAddress, quantity) {
+
+    const pdu = Buffer.allocUnsafe(5);
+
+    pdu.writeUInt8(16, 0);
+
+    pdu.writeUInt16BE(startAddress & 0xFFFF, 1);
+
+    pdu.writeUInt16BE(quantity & 0xFFFF, 3);
+
+
+    const response = Buffer.allocUnsafe(7 + pdu.length);
+
+    response.writeUInt16BE(transactionId, 0);
+
+    response.writeUInt16BE(0, 2);
+
+    response.writeUInt16BE(pdu.length + 1, 4);
+
+    response.writeUInt8(unitId, 6);
+
+    pdu.copy(response, 7);
+
+    return response;
+
+}
+
+
+function createModbusServer(options) {
+
+    const maxConnections = Math.max(1, Number(options.maxConnections || 20));
+    const socketIdleTimeoutMs = Math.max(500, Number(options.socketIdleTimeoutMs || 30000));
+    const rateLimitPerSecond = Math.max(0, Number(options.rateLimitPerSecond || 0));
+
+    let server = null;
+    let clientCount = 0;
+    const sockets = new Set();
+    const requestsByClient = new Map();
+
+    function emitProtocolIssue(code, details) {
+
+        notify(options, "onProtocolIssue", Object.assign({
+            code: code,
+            timestampMs: Date.now()
+        }, details || {}));
+
+    }
+
+    function isRateLimited(remoteAddress) {
+
+        if (!rateLimitPerSecond || !remoteAddress) {
+            return false;
+        }
+
+        const now = Date.now();
+        const existing = requestsByClient.get(remoteAddress) || { windowStartMs: now, count: 0 };
+
+        if ((now - existing.windowStartMs) >= 1000) {
+            existing.windowStartMs = now;
+            existing.count = 0;
+        }
+
+        existing.count += 1;
+        requestsByClient.set(remoteAddress, existing);
+
+        return existing.count > rateLimitPerSecond;
+
+    }
+
+    function start() {
+
+        if (server) {
+            return Promise.resolve();
+        }
+
+        server = net.createServer(function (socket) {
+
+            const remoteAddress = normalizeIp(socket.remoteAddress);
+
+            if (clientCount >= maxConnections) {
+                emitProtocolIssue("max_connections_exceeded", { remoteAddress: remoteAddress });
+                socket.destroy();
+                return;
+            }
+
+            sockets.add(socket);
+            clientCount += 1;
+            notify(options, "onClientChange", clientCount);
+            notify(options, "onClientConnected", {
+                remoteAddress: remoteAddress,
+                remotePort: socket.remotePort || null,
+                timestampMs: Date.now(),
+                clientCount: clientCount
+            });
+
+            let rxBuffer = Buffer.alloc(0);
+
+            socket.setTimeout(socketIdleTimeoutMs);
+
+            socket.on("timeout", function () {
+                emitProtocolIssue("socket_idle_timeout", { remoteAddress: remoteAddress });
+                socket.destroy();
+            });
+
+            socket.on("data", function (chunk) {
+
+                try {
+
+                    if (!Buffer.isBuffer(chunk) || !chunk.length) {
+                        return;
+                    }
+
+                    rxBuffer = rxBuffer.length ? Buffer.concat([rxBuffer, chunk]) : chunk;
+
+                    while (rxBuffer.length >= 7) {
+
+                        const length = rxBuffer.readUInt16BE(4);
+                        const frameLength = 6 + length;
+
+                        if (length < 2) {
+                            emitProtocolIssue("invalid_mbap_length", { remoteAddress: remoteAddress, length: length });
+                            rxBuffer = Buffer.alloc(0);
+                            break;
+                        }
+
+                        if (rxBuffer.length < frameLength) {
+                            break;
+                        }
+
+                        const frame = rxBuffer.subarray(0, frameLength);
+                        rxBuffer = rxBuffer.subarray(frameLength);
+
+                        if (frame.length < 12) {
+                            emitProtocolIssue("short_frame", { remoteAddress: remoteAddress, frameLength: frame.length });
+                            continue;
+                        }
+
+                        const transactionId = frame.readUInt16BE(0);
+                        const protocolId = frame.readUInt16BE(2);
+                        const unitId = frame.readUInt8(6);
+                        const functionCode = frame.readUInt8(7);
+
+                        if (protocolId !== 0) {
+                            emitProtocolIssue("invalid_protocol_id", { remoteAddress: remoteAddress, protocolId: protocolId });
+                            socket.write(exceptionResponse(transactionId, unitId, functionCode || 0, 4));
+                            continue;
+                        }
+
+                        if (options.unitId !== 0 && unitId !== options.unitId) {
+                            emitProtocolIssue("unit_id_mismatch", { remoteAddress: remoteAddress, expectedUnitId: options.unitId, actualUnitId: unitId });
+                            socket.write(exceptionResponse(transactionId, unitId, functionCode, 11));
+                            continue;
+                        }
+
+                        if (functionCode !== 3 && functionCode !== 4 && functionCode !== 6 && functionCode !== 16) {
+                            emitProtocolIssue("unsupported_function", { remoteAddress: remoteAddress, functionCode: functionCode });
+                            socket.write(exceptionResponse(transactionId, unitId, functionCode, 1));
+                            continue;
+                        }
+
+                        if (isRateLimited(remoteAddress)) {
+                            emitProtocolIssue("rate_limited", { remoteAddress: remoteAddress, rateLimitPerSecond: rateLimitPerSecond });
+                            socket.write(exceptionResponse(transactionId, unitId, functionCode, 6));
+                            continue;
+                        }
+
+                        const startAddress = frame.readUInt16BE(8);
+
+                        if (functionCode === 6) {
+                            const value = frame.readUInt16BE(10);
+
+                            if (typeof options.writeSingleRegister !== "function") {
+                                emitProtocolIssue("write_not_supported", { remoteAddress: remoteAddress, functionCode: functionCode });
+                                socket.write(exceptionResponse(transactionId, unitId, functionCode, 1));
+                                continue;
+                            }
+
+                            notify(options, "onWrite", {
+                                remoteAddress: remoteAddress,
+                                unitId: unitId,
+                                functionCode: functionCode,
+                                startAddress: startAddress,
+                                quantity: 1,
+                                values: [value],
+                                timestampMs: Date.now()
+                            });
+
+                            const writeResult = options.writeSingleRegister(startAddress, value);
+
+                            if (writeResult && typeof writeResult === "object" && writeResult.exceptionCode) {
+                                emitProtocolIssue(writeResult.issueCode || "write_exception", {
+                                    remoteAddress: remoteAddress,
+                                    startAddress: startAddress,
+                                    quantity: 1,
+                                    exceptionCode: writeResult.exceptionCode
+                                });
+                                socket.write(exceptionResponse(transactionId, unitId, functionCode, writeResult.exceptionCode));
+                                continue;
+                            }
+
+                            socket.write(writeSingleRegisterResponse(transactionId, unitId, startAddress, value));
+                            continue;
+                        }
+
+                        const quantity = frame.readUInt16BE(10);
+
+                        if (functionCode === 16) {
+                            const byteCount = frame.readUInt8(12);
+
+                            if (quantity < 1 || quantity > 123 || byteCount !== quantity * 2 || frame.length < (13 + byteCount)) {
+                                emitProtocolIssue("invalid_write_multiple", { remoteAddress: remoteAddress, quantity: quantity, byteCount: byteCount });
+                                socket.write(exceptionResponse(transactionId, unitId, functionCode, 3));
+                                continue;
+                            }
+
+                            if (typeof options.writeHoldingRegisters !== "function") {
+                                emitProtocolIssue("write_not_supported", { remoteAddress: remoteAddress, functionCode: functionCode });
+                                socket.write(exceptionResponse(transactionId, unitId, functionCode, 1));
+                                continue;
+                            }
+
+                            const values = [];
+                            for (let i = 0; i < quantity; i++) {
+                                values.push(frame.readUInt16BE(13 + (i * 2)));
+                            }
+
+                            notify(options, "onWrite", {
+                                remoteAddress: remoteAddress,
+                                unitId: unitId,
+                                functionCode: functionCode,
+                                startAddress: startAddress,
+                                quantity: quantity,
+                                values: values,
+                                timestampMs: Date.now()
+                            });
+
+                            const writeResult = options.writeHoldingRegisters(startAddress, values);
+
+                            if (writeResult && typeof writeResult === "object" && writeResult.exceptionCode) {
+                                emitProtocolIssue(writeResult.issueCode || "write_exception", {
+                                    remoteAddress: remoteAddress,
+                                    startAddress: startAddress,
+                                    quantity: quantity,
+                                    exceptionCode: writeResult.exceptionCode
+                                });
+                                socket.write(exceptionResponse(transactionId, unitId, functionCode, writeResult.exceptionCode));
+                                continue;
+                            }
+
+                            socket.write(writeMultipleRegistersResponse(transactionId, unitId, startAddress, quantity));
+                            continue;
+                        }
+
+                        if (quantity < 1 || quantity > 125) {
+                            emitProtocolIssue("invalid_quantity", { remoteAddress: remoteAddress, quantity: quantity });
+                            socket.write(exceptionResponse(transactionId, unitId, functionCode, 3));
+                            continue;
+                        }
+
+                        notify(options, "onRead", {
+                            remoteAddress: remoteAddress,
+                            unitId: unitId,
+                            functionCode: functionCode,
+                            startAddress: startAddress,
+                            quantity: quantity,
+                            timestampMs: Date.now()
+                        });
+
+                        const readResult = options.readHoldingRegisters(startAddress, quantity);
+
+                        if (readResult && typeof readResult === "object" && !Array.isArray(readResult) && readResult.exceptionCode) {
+                            emitProtocolIssue(readResult.issueCode || "read_exception", {
+                                remoteAddress: remoteAddress,
+                                startAddress: startAddress,
+                                quantity: quantity,
+                                exceptionCode: readResult.exceptionCode
+                            });
+                            socket.write(exceptionResponse(transactionId, unitId, functionCode, readResult.exceptionCode));
+                            continue;
+                        }
+
+                        const words = Array.isArray(readResult) ? readResult : [];
+                        socket.write(registerResponse(transactionId, unitId, functionCode, words));
+
+                    }
+
+                } catch (err) {
+
+                    emitProtocolIssue("parser_error", { remoteAddress: remoteAddress, message: err.message });
+                    notify(options, "onError", err);
+
+                }
+
+            });
+
+            socket.on("close", function () {
+
+                sockets.delete(socket);
+                clientCount = Math.max(0, clientCount - 1);
+                notify(options, "onClientChange", clientCount);
+                notify(options, "onClientDisconnected", {
+                    remoteAddress: remoteAddress,
+                    timestampMs: Date.now(),
+                    clientCount: clientCount
+                });
+
+            });
+
+            socket.on("error", function (err) {
+                emitProtocolIssue("socket_error", { remoteAddress: remoteAddress, message: err.message });
+                notify(options, "onError", err);
+            });
+
+        });
+
+        return new Promise(function (resolve, reject) {
+
+            function handleListenError(err) {
+                server = null;
+                reject(err);
+            }
+
+            server.once("error", handleListenError);
+
+            server.listen(options.port, options.host, function () {
+
+                server.off("error", handleListenError);
+                resolve();
+
+            });
+
+        });
+
+    }
+
+    function stop() {
+
+        if (!server) {
+            return Promise.resolve();
+        }
+
+        const current = server;
+        server = null;
+
+        return new Promise(function (resolve) {
+
+            sockets.forEach(function (socket) {
+                socket.destroy();
+            });
+
+            current.close(function () {
+                clientCount = 0;
+                sockets.clear();
+                requestsByClient.clear();
+                notify(options, "onClientChange", clientCount);
+                resolve();
+            });
+
+        });
+
+    }
+
+    return {
+        start,
+        stop,
+        address: function () {
+            return server ? server.address() : null;
+        }
+    };
+
+}
+
+
+module.exports = {
+    createModbusServer
+};

package/scada-server/lib/object-path.js

@@ -0,0 +1,18 @@
+"use strict";
+
+
+function getByPath(source, path) {
+
+    if (!source || !path) {
+        return undefined;
+    }
+
+    return String(path).split(".").reduce(function (acc, key) {
+        return acc != null ? acc[key] : undefined;
+    }, source);
+}
+
+
+module.exports = {
+    getByPath
+};