node-red-contrib-tcp-client-server-avd 1.0.0

package/NodeRedTCP/nodes/tcp-client-server-avd.js

@@ -0,0 +1,606 @@
+/**
+ * Node-RED TCP Client/Server Node
+ * Implementatie volgens SPECIFICATIE.md
+ */
+
+module.exports = function(RED) {
+    "use strict";
+    const net = require('net');
+    const crypto = require('crypto');
+
+    // Helper functie voor UUID generatie
+    function generateId() {
+        if (typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        // Fallback voor oudere Node.js versies
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    // Data formatting functies
+    function formatOutput(data, format, encoding) {
+        if (format === "string") {
+            if (Buffer.isBuffer(data)) {
+                return data.toString(encoding || 'utf8');
+            }
+            return String(data);
+        } else if (format === "buffer") {
+            if (Buffer.isBuffer(data)) {
+                return data;
+            }
+            return Buffer.from(data);
+        } else if (format === "json") {
+            if (Buffer.isBuffer(data)) {
+                try {
+                    return JSON.parse(data.toString(encoding || 'utf8'));
+                } catch (e) {
+                    return { raw: data.toString(encoding || 'utf8') };
+                }
+            }
+            if (typeof data === 'string') {
+                try {
+                    return JSON.parse(data);
+                } catch (e) {
+                    return data;
+                }
+            }
+            return data;
+        } else if (format === "hex") {
+            if (Buffer.isBuffer(data)) {
+                return data.toString('hex');
+            }
+            if (typeof data === 'string') {
+                return Buffer.from(data, encoding || 'utf8').toString('hex');
+            }
+            return Buffer.from(String(data)).toString('hex');
+        }
+        return data;
+    }
+
+    function formatInput(data, format, encoding) {
+        if (format === "string") {
+            if (Buffer.isBuffer(data)) {
+                return data.toString(encoding || 'utf8');
+            }
+            if (typeof data === 'object') {
+                return JSON.stringify(data);
+            }
+            return String(data);
+        } else if (format === "buffer") {
+            if (Buffer.isBuffer(data)) {
+                return data;
+            }
+            if (typeof data === 'string') {
+                return Buffer.from(data, encoding || 'utf8');
+            }
+            return Buffer.from(String(data));
+        } else if (format === "json") {
+            if (Buffer.isBuffer(data)) {
+                return data;
+            }
+            if (typeof data === 'string') {
+                return Buffer.from(data, encoding || 'utf8');
+            }
+            if (typeof data === 'object') {
+                return Buffer.from(JSON.stringify(data), encoding || 'utf8');
+            }
+            return Buffer.from(String(data), encoding || 'utf8');
+        } else if (format === "hex") {
+            if (typeof data === 'string') {
+                // Verwijder eventuele spaties en controleer op hex
+                const hex = data.replace(/\s/g, '');
+                if (/^[0-9a-fA-F]+$/.test(hex)) {
+                    return Buffer.from(hex, 'hex');
+                }
+                return Buffer.from(data, encoding || 'utf8');
+            }
+            return Buffer.from(String(data), encoding || 'utf8');
+        }
+        return Buffer.from(String(data), encoding || 'utf8');
+    }
+
+    function TCPClientServerNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Configuratie
+        node.mode = config.mode || "client";
+        node.name = config.name || "";
+
+        // Client configuratie
+        node.clientConfig = {
+            host: config.clientHost || "localhost",
+            port: parseInt(config.clientPort) || 8080,
+            ipVersion: config.clientIpVersion || "4",
+            autoConnect: config.clientAutoConnect !== false,
+            reconnect: config.clientReconnect !== false,
+            reconnectInterval: parseInt(config.clientReconnectInterval) || 5,
+            maxReconnectAttempts: parseInt(config.clientMaxReconnectAttempts) || 0,
+            connectionTimeout: parseInt(config.clientConnectionTimeout) || 10,
+            inputFormat: config.clientInputFormat || "string",
+            outputFormat: config.clientOutputFormat || "string",
+            encoding: config.clientEncoding || "utf8",
+            delimiter: config.clientDelimiter || "",
+            keepAlive: config.clientKeepAlive === true
+        };
+
+        // Server configuratie
+        node.serverConfig = {
+            port: parseInt(config.serverPort) || 8080,
+            bindAddress: config.serverBindAddress || "0.0.0.0",
+            ipVersion: config.serverIpVersion || "4",
+            autoStart: config.serverAutoStart !== false,
+            maxConnections: parseInt(config.serverMaxConnections) || 0,
+            connectionTimeout: parseInt(config.serverConnectionTimeout) || 600,
+            inputFormat: config.serverInputFormat || "string",
+            outputFormat: config.serverOutputFormat || "string",
+            encoding: config.serverEncoding || "utf8",
+            delimiter: config.serverDelimiter || "",
+            keepAlive: config.serverKeepAlive === true
+        };
+
+        // Client state
+        node.clientSocket = null;
+        node.clientConnected = false;
+        node.clientReconnectTimer = null;
+        node.clientReconnectAttempts = 0;
+        node.clientBuffer = Buffer.alloc(0);
+
+        // Server state
+        node.server = null;
+        node.serverListening = false;
+        node.serverClients = new Map(); // clientId -> socket
+        node.clientBuffers = new Map(); // clientId -> buffer
+
+        // Delimiter processing helper
+        function parseDelimiter(delimiter, encoding) {
+            if (delimiter === "\\n") {
+                return Buffer.from("\n");
+            } else if (delimiter === "\\r\\n") {
+                return Buffer.from("\r\n");
+            } else if (delimiter === "\\r") {
+                return Buffer.from("\r");
+            } else {
+                return Buffer.from(delimiter, encoding);
+            }
+        }
+
+        // Client functionaliteit
+        function initClient() {
+            if (node.mode !== "client" && node.mode !== "both") {
+                return;
+            }
+
+            if (node.clientConfig.autoConnect) {
+                clientConnect();
+            } else {
+                node.status({ fill: "grey", shape: "ring", text: "niet verbonden" });
+            }
+        }
+
+        function clientConnect() {
+            if (node.clientSocket && node.clientConnected) {
+                return;
+            }
+
+            if (node.clientSocket) {
+                node.clientSocket.destroy();
+            }
+
+            node.status({ fill: "yellow", shape: "ring", text: "verbinden..." });
+
+            const options = {
+                port: node.clientConfig.port,
+                host: node.clientConfig.host,
+                family: node.clientConfig.ipVersion === "6" ? 6 : 4
+            };
+
+            if (node.clientConfig.keepAlive) {
+                options.keepAlive = true;
+            }
+
+            const socket = new net.Socket();
+            node.clientSocket = socket;
+            node.clientBuffer = Buffer.alloc(0);
+
+            // Timeout alleen voor connect, niet voor idle
+            socket.setTimeout(node.clientConfig.connectionTimeout * 1000);
+
+            socket.on('connect', function() {
+                node.clientConnected = true;
+                node.clientReconnectAttempts = 0;
+                // Schakel timeout uit na succesvolle connectie (geen idle timeout)
+                socket.setTimeout(0);
+                node.status({ fill: "green", shape: "dot", text: `verbonden ${node.clientConfig.host}:${node.clientConfig.port}` });
+                
+                const msg = {
+                    topic: "status",
+                    payload: "connected",
+                    status: "connected"
+                };
+                node.send(msg);
+            });
+
+            socket.on('data', function(data) {
+                if (node.clientConfig.delimiter) {
+                    const combined = Buffer.concat([node.clientBuffer, data]);
+                    const delim = parseDelimiter(node.clientConfig.delimiter, node.clientConfig.encoding);
+                    let offset = 0;
+                    let index;
+
+                    while ((index = combined.indexOf(delim, offset)) !== -1) {
+                        const message = combined.slice(offset, index);
+                        const formatted = formatOutput(message, node.clientConfig.outputFormat, node.clientConfig.encoding);
+                        const msg = {
+                            topic: "data",
+                            payload: formatted,
+                            timestamp: new Date().toISOString()
+                        };
+                        node.send(msg);
+                        offset = index + delim.length;
+                    }
+                    node.clientBuffer = combined.slice(offset);
+                } else {
+                    const formatted = formatOutput(data, node.clientConfig.outputFormat, node.clientConfig.encoding);
+                    const msg = {
+                        topic: "data",
+                        payload: formatted,
+                        timestamp: new Date().toISOString()
+                    };
+                    node.send(msg);
+                }
+            });
+
+            socket.on('close', function(hadError) {
+                node.clientConnected = false;
+                node.status({ fill: "red", shape: "ring", text: "verbinding gesloten" });
+                
+                const msg = {
+                    topic: "status",
+                    payload: "disconnected",
+                    status: "disconnected",
+                    error: hadError ? "connection closed with error" : undefined
+                };
+                node.send(msg);
+
+                if (node.clientConfig.reconnect && (node.clientConfig.maxReconnectAttempts === 0 || node.clientReconnectAttempts < node.clientConfig.maxReconnectAttempts)) {
+                    node.clientReconnectAttempts++;
+                    node.clientReconnectTimer = setTimeout(function() {
+                        clientConnect();
+                    }, node.clientConfig.reconnectInterval * 1000);
+                    node.status({ fill: "yellow", shape: "ring", text: `herconnectie in ${node.clientConfig.reconnectInterval}s...` });
+                }
+            });
+
+            socket.on('error', function(err) {
+                node.clientConnected = false;
+                node.status({ fill: "red", shape: "ring", text: `fout: ${err.message}` });
+                
+                const msg = {
+                    topic: "status",
+                    payload: "error",
+                    status: "error",
+                    error: err.message
+                };
+                node.send(msg);
+            });
+
+            socket.on('timeout', function() {
+                // Timeout wordt alleen gebruikt tijdens connect, niet tijdens verbonden state
+                if (!node.clientConnected) {
+                    socket.destroy();
+                    node.clientConnected = false;
+                    node.status({ fill: "red", shape: "ring", text: "connect timeout" });
+                }
+            });
+
+            socket.connect(options);
+        }
+
+        function clientDisconnect() {
+            if (node.clientReconnectTimer) {
+                clearTimeout(node.clientReconnectTimer);
+                node.clientReconnectTimer = null;
+            }
+            if (node.clientSocket) {
+                node.clientSocket.destroy();
+                node.clientSocket = null;
+            }
+            node.clientConnected = false;
+            node.clientReconnectAttempts = 0;
+            node.status({ fill: "grey", shape: "ring", text: "niet verbonden" });
+        }
+
+        function clientSend(data) {
+            if (!node.clientSocket || !node.clientConnected) {
+                node.error("Client niet verbonden");
+                return;
+            }
+
+            try {
+                const formatted = formatInput(data, node.clientConfig.inputFormat, node.clientConfig.encoding);
+                let toSend = formatted;
+
+                if (node.clientConfig.delimiter) {
+                    const delim = parseDelimiter(node.clientConfig.delimiter, node.clientConfig.encoding);
+                    toSend = Buffer.concat([formatted, delim]);
+                }
+
+                node.clientSocket.write(toSend);
+            } catch (err) {
+                node.error("Fout bij verzenden: " + err.message);
+            }
+        }
+
+        // Server functionaliteit
+        function initServer() {
+            if (node.mode !== "server" && node.mode !== "both") {
+                return;
+            }
+
+            if (node.serverConfig.autoStart) {
+                serverStart();
+            } else {
+                node.status({ fill: "grey", shape: "ring", text: "server gestopt" });
+            }
+        }
+
+        function serverStart() {
+            if (node.server && node.serverListening) {
+                return;
+            }
+
+            if (node.server) {
+                node.server.close();
+            }
+
+            const options = {
+                family: node.serverConfig.ipVersion === "6" ? 6 : 4
+            };
+
+            node.server = net.createServer(options, function(socket) {
+                const clientId = generateId();
+                const remoteAddress = socket.remoteAddress;
+                const remotePort = socket.remotePort;
+
+                // Check max connections
+                if (node.serverConfig.maxConnections > 0 && node.serverClients.size >= node.serverConfig.maxConnections) {
+                    socket.destroy();
+                    return;
+                }
+
+                node.serverClients.set(clientId, socket);
+                node.clientBuffers.set(clientId, Buffer.alloc(0));
+
+                if (node.serverConfig.keepAlive) {
+                    socket.setKeepAlive(true);
+                }
+
+                socket.setTimeout(node.serverConfig.connectionTimeout * 1000);
+
+                // Client connected message
+                const connectMsg = {
+                    topic: "client/connected",
+                    clientId: clientId,
+                    remoteAddress: remoteAddress,
+                    remotePort: remotePort
+                };
+                node.send(connectMsg);
+
+                // Update status
+                updateServerStatus();
+
+                socket.on('data', function(data) {
+                    if (node.serverConfig.delimiter) {
+                        let buffer = node.clientBuffers.get(clientId) || Buffer.alloc(0);
+                        buffer = Buffer.concat([buffer, data]);
+                        const delim = parseDelimiter(node.serverConfig.delimiter, node.serverConfig.encoding);
+
+                        let offset = 0;
+                        let index;
+                        while ((index = buffer.indexOf(delim, offset)) !== -1) {
+                            const message = buffer.slice(offset, index);
+                            const formatted = formatOutput(message, node.serverConfig.outputFormat, node.serverConfig.encoding);
+                            const msg = {
+                                topic: "data",
+                                payload: formatted,
+                                clientId: clientId,
+                                remoteAddress: remoteAddress,
+                                remotePort: remotePort,
+                                timestamp: new Date().toISOString()
+                            };
+                            node.send(msg);
+                            offset = index + delim.length;
+                        }
+                        node.clientBuffers.set(clientId, buffer.slice(offset));
+                    } else {
+                        const formatted = formatOutput(data, node.serverConfig.outputFormat, node.serverConfig.encoding);
+                        const msg = {
+                            topic: "data",
+                            payload: formatted,
+                            clientId: clientId,
+                            remoteAddress: remoteAddress,
+                            remotePort: remotePort,
+                            timestamp: new Date().toISOString()
+                        };
+                        node.send(msg);
+                    }
+                });
+
+                socket.on('close', function() {
+                    node.serverClients.delete(clientId);
+                    node.clientBuffers.delete(clientId);
+
+                    const disconnectMsg = {
+                        topic: "client/disconnected",
+                        clientId: clientId
+                    };
+                    node.send(disconnectMsg);
+
+                    updateServerStatus();
+                });
+
+                socket.on('error', function(err) {
+                    node.error("Client socket error: " + err.message);
+                });
+
+                socket.on('timeout', function() {
+                    // Timeout wordt gebruikt voor idle detection (optioneel)
+                    // Als timeout is ingesteld, sluit dan de verbinding na idle periode
+                    socket.destroy();
+                });
+            });
+
+            node.server.on('error', function(err) {
+                node.serverListening = false;
+                node.status({ fill: "red", shape: "ring", text: `fout: ${err.message}` });
+                
+                const msg = {
+                    topic: "status",
+                    payload: "error",
+                    status: "error",
+                    port: node.serverConfig.port,
+                    error: err.message
+                };
+                node.send(msg);
+            });
+
+            node.server.listen(node.serverConfig.port, node.serverConfig.bindAddress, function() {
+                node.serverListening = true;
+                updateServerStatus();
+                
+                const msg = {
+                    topic: "status",
+                    payload: "listening",
+                    status: "listening",
+                    port: node.serverConfig.port
+                };
+                node.send(msg);
+            });
+        }
+
+        function serverStop() {
+            if (node.server) {
+                // Close all client connections
+                node.serverClients.forEach(function(socket, clientId) {
+                    socket.destroy();
+                });
+                node.serverClients.clear();
+                node.clientBuffers.clear();
+
+                node.server.close(function() {
+                    node.server = null;
+                    node.serverListening = false;
+                    node.status({ fill: "grey", shape: "ring", text: "server gestopt" });
+                    
+                    const msg = {
+                        topic: "status",
+                        payload: "stopped",
+                        status: "stopped",
+                        port: node.serverConfig.port
+                    };
+                    node.send(msg);
+                });
+            }
+        }
+
+        function updateServerStatus() {
+            const clientCount = node.serverClients.size;
+            if (node.serverListening) {
+                if (clientCount > 0) {
+                    node.status({ fill: "blue", shape: "dot", text: `luisteren op ${node.serverConfig.port} (${clientCount} clients)` });
+                } else {
+                    node.status({ fill: "green", shape: "dot", text: `luisteren op ${node.serverConfig.port}` });
+                }
+            }
+        }
+
+        function serverSend(clientId, data) {
+            const socket = node.serverClients.get(clientId);
+            if (!socket) {
+                node.error(`Client ${clientId} niet gevonden`);
+                return;
+            }
+
+            try {
+                const formatted = formatInput(data, node.serverConfig.inputFormat, node.serverConfig.encoding);
+                let toSend = formatted;
+
+                if (node.serverConfig.delimiter) {
+                    const delim = parseDelimiter(node.serverConfig.delimiter, node.serverConfig.encoding);
+                    toSend = Buffer.concat([formatted, delim]);
+                }
+
+                socket.write(toSend);
+            } catch (err) {
+                node.error("Fout bij verzenden: " + err.message);
+            }
+        }
+
+        function serverBroadcast(data) {
+            node.serverClients.forEach(function(socket, clientId) {
+                serverSend(clientId, data);
+            });
+        }
+
+        // Input message handler
+        node.on('input', function(msg) {
+            const topic = msg.topic || "";
+            const payload = msg.payload;
+
+            if (node.mode === "client" || node.mode === "both") {
+                if (topic === "connect") {
+                    clientConnect();
+                    return;
+                } else if (topic === "disconnect") {
+                    clientDisconnect();
+                    return;
+                } else if (topic === "send" || !topic) {
+                    // Default: send data
+                    clientSend(payload);
+                    return;
+                }
+            }
+
+            if (node.mode === "server" || node.mode === "both") {
+                if (topic === "start") {
+                    serverStart();
+                    return;
+                } else if (topic === "stop") {
+                    serverStop();
+                    return;
+                } else if (topic === "send") {
+                    if (msg.clientId) {
+                        serverSend(msg.clientId, payload);
+                    } else {
+                        node.error("clientId vereist voor server send");
+                    }
+                    return;
+                } else if (topic === "broadcast") {
+                    serverBroadcast(payload);
+                    return;
+                }
+            }
+        });
+
+        // Cleanup bij node close
+        node.on('close', function() {
+            if (node.clientSocket) {
+                clientDisconnect();
+            }
+            if (node.server) {
+                serverStop();
+            }
+        });
+
+        // Initialize
+        initClient();
+        initServer();
+    }
+
+    RED.nodes.registerType("tcp-client-server-avd", TCPClientServerNode);
+};

package/NodeRedTCP/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "node-red-contrib-tcp-client-server-avd",
+  "version": "1.0.0",
+  "description": "Node-RED node voor TCP client en/of server functionaliteit",
+  "main": "nodes/tcp-client-server-avd.js",
+  "keywords": [
+    "node-red",
+    "tcp",
+    "client",
+    "server",
+    "socket"
+  ],
+  "node-red": {
+    "nodes": {
+      "tcp-client-server-avd": "nodes/tcp-client-server-avd.js"
+    }
+  },
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "dependencies": {},
+  "files": [
+    "nodes/",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": ""
+  }
+}