node-red-contrib-my-tools 1.0.0

package/node-red-contrib-s7-plus/lib/s7plus/tag-routing.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const HEX_ADDRESS_RE = /^[0-9A-Fa-f]+(\.[0-9A-Fa-f]+)*$/;
+
+/**
+ * Determine if a symbol string is a raw hex access address (as returned
+ * by browseResolve, e.g. "8A0E0001.A.0") rather than a symbolic path.
+ * Hex addresses consist solely of hex digits separated by dots.
+ */
+function isHexAddress(str) {
+    return HEX_ADDRESS_RE.test(str);
+}
+
+/**
+ * Determine if a name string looks like a symbolic PLC path. Symbolic
+ * paths contain dots with at least one non-hex segment, or brackets
+ * (array indexing). Used to decide whether a tag must be resolved
+ * (CRC-secured) before reading/writing.
+ */
+function isSymbolicName(name) {
+    if (!name || typeof name !== 'string') return false;
+    if (isHexAddress(name)) return false;
+    return /[.\[]/.test(name);
+}
+
+module.exports = {
+    HEX_ADDRESS_RE,
+    isHexAddress,
+    isSymbolicName
+};

package/node-red-contrib-s7-plus/lib/s7plus/transport/cotp-stream.js

@@ -0,0 +1,335 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+const { Duplex } = require('stream');
+
+const ISO_HEADER_SIZE = 7;
+const TPKT_COTP_HEADER = Buffer.from([0x03, 0x00, 0x00, 0x1f, 0x02, 0xf0, 0x80]);
+const MAX_PAYLOAD = 16 * 1024;
+
+const READER_KEY = Symbol('s7plus.socketReader');
+
+function getWord(b, pos) {
+    return (b[pos] << 8) | b[pos + 1];
+}
+
+function setWord(b, pos, value) {
+    b[pos] = (value >> 8) & 0xff;
+    b[pos + 1] = value & 0xff;
+}
+
+/**
+ * Persistent buffered reader attached to a socket via a Symbol.
+ * Mirrors the synchronous Stream.Read accumulation pattern used in the C# driver
+ * and avoids Node's flowing-mode + unshift() data-loss pitfall.
+ */
+class SocketReader {
+    constructor(socket) {
+        this.socket = socket;
+        this.chunks = [];
+        this.totalLen = 0;
+        this.waiter = null;
+        this.error = null;
+        this._onData = (chunk) => {
+            this.chunks.push(chunk);
+            this.totalLen += chunk.length;
+            this._tryResolve();
+        };
+        this._onErr = (err) => this._fail(err);
+        this._onClose = () => this._fail(new Error('Socket closed'));
+        socket.on('data', this._onData);
+        socket.on('error', this._onErr);
+        socket.on('close', this._onClose);
+    }
+
+    _tryResolve() {
+        if (!this.waiter) return;
+        if (this.totalLen < this.waiter.count) return;
+        const w = this.waiter;
+        this.waiter = null;
+        clearTimeout(w.timer);
+        w.resolve(this._consume(w.count));
+    }
+
+    _consume(count) {
+        const out = Buffer.alloc(count);
+        let offset = 0;
+        while (offset < count) {
+            const head = this.chunks[0];
+            const take = Math.min(count - offset, head.length);
+            head.copy(out, offset, 0, take);
+            offset += take;
+            this.totalLen -= take;
+            if (take === head.length) {
+                this.chunks.shift();
+            } else {
+                this.chunks[0] = head.subarray(take);
+            }
+        }
+        return out;
+    }
+
+    _fail(err) {
+        if (!this.error) this.error = err;
+        const w = this.waiter;
+        if (w) {
+            this.waiter = null;
+            clearTimeout(w.timer);
+            w.reject(err);
+        }
+    }
+
+    /**
+     * Read exactly `count` bytes. If `timeoutMs > 0`, reject after that
+     * many ms with 'COTP read timeout'. If `timeoutMs <= 0` or not finite,
+     * wait indefinitely — used by the recv loop's "wait for next packet"
+     * read, where an idle connection MUST NOT be treated as a timeout
+     * (otherwise the loop dies silently every `timeoutMs` ms of idle).
+     */
+    read(count, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            if (this.error && this.totalLen < count) {
+                return reject(this.error);
+            }
+            if (this.totalLen >= count) {
+                return resolve(this._consume(count));
+            }
+            if (this.waiter) {
+                return reject(new Error('SocketReader: concurrent read not supported'));
+            }
+            let timer = null;
+            if (timeoutMs > 0 && Number.isFinite(timeoutMs)) {
+                timer = setTimeout(() => {
+                    if (this.waiter && this.waiter.timer === timer) {
+                        this.waiter = null;
+                        reject(new Error('COTP read timeout'));
+                    }
+                }, timeoutMs);
+            }
+            this.waiter = { count, timer, resolve, reject };
+        });
+    }
+
+    /**
+     * Aborts the currently pending read (if any) without dropping buffered bytes
+     * and without marking the reader as failed. The reader can immediately be
+     * reused by a new consumer (e.g. when switching from plain to TLS framing).
+     */
+    interrupt(reason) {
+        const w = this.waiter;
+        if (w) {
+            this.waiter = null;
+            clearTimeout(w.timer);
+            const err = new Error(reason || 'SocketReader: read interrupted');
+            err.code = 'EREADINTERRUPTED';
+            w.reject(err);
+        }
+    }
+
+    dispose() {
+        this.socket.removeListener('data', this._onData);
+        this.socket.removeListener('error', this._onErr);
+        this.socket.removeListener('close', this._onClose);
+        const w = this.waiter;
+        if (w) {
+            this.waiter = null;
+            clearTimeout(w.timer);
+            w.reject(new Error('SocketReader disposed'));
+        }
+    }
+}
+
+function getReader(socket) {
+    let r = socket[READER_KEY];
+    if (!r) {
+        r = new SocketReader(socket);
+        socket[READER_KEY] = r;
+    }
+    return r;
+}
+
+function readExactly(socket, count, timeoutMs) {
+    return getReader(socket).read(count, timeoutMs);
+}
+
+function disposeReader(socket) {
+    const r = socket[READER_KEY];
+    if (r) {
+        r.dispose();
+        delete socket[READER_KEY];
+    }
+}
+
+function interruptReader(socket, reason) {
+    const r = socket[READER_KEY];
+    if (r) r.interrupt(reason);
+}
+
+/**
+ * Framed ISO-on-TCP stream for TLS layer (matches CotpStream.cs).
+ */
+class CotpStream extends EventEmitter {
+    constructor(innerSocket, timeoutMs = 60000) {
+        super();
+        this._socket = innerSocket;
+        this._timeoutMs = timeoutMs;
+        this._queue = [];
+        this._current = null;
+        this._offset = 0;
+        this._closed = false;
+        this._syncReaderActive = false;
+        this._recvLoop();
+    }
+
+    async _recvLoop() {
+        const lenBuf = Buffer.alloc(4);
+        try {
+            while (!this._closed && !this._socket.destroyed) {
+                // Wait indefinitely for the next packet header. Idle
+                // connections are normal — only an actual socket close
+                // or error should terminate this loop.
+                const h = await readExactly(this._socket, 4, 0);
+                h.copy(lenBuf, 0);
+                if (lenBuf[0] !== 0x03) continue;
+                const packetLen = getWord(lenBuf, 2);
+                if (packetLen < ISO_HEADER_SIZE) continue;
+                const toRead = packetLen - 4;
+                // Mid-packet: once we have the header, the body MUST
+                // arrive within timeoutMs. A stalled mid-packet read
+                // indicates real trouble.
+                const rest = await readExactly(this._socket, toRead, this._timeoutMs);
+                const payloadLen = toRead - 3;
+                if (payloadLen <= 0) continue;
+                const payload = rest.subarray(3, 3 + payloadLen);
+                // The 'packet' event is the only active consumer (CotpDuplex
+                // for the TLS pipeline). The _queue/_drain/readSync path is
+                // dead code in this driver — pushing here without a drainer
+                // grows _queue monotonically with every PLC frame and pins
+                // every received COTP buffer in the arrayBuffers pool, which
+                // eventually freezes Node-RED. Only buffer for readSync if a
+                // sync reader has actually subscribed.
+                if (this._syncReaderActive) this._queue.push(payload);
+                this.emit('packet', payload);
+            }
+        } catch (_) {
+            /* connection ended — _installSocketWatch on the wrapping
+               transport surfaces this via a 'close' event */
+        } finally {
+            this._closed = true;
+        }
+    }
+
+    _drain(buf, offset, count) {
+        let written = 0;
+        while (written < count) {
+            if (!this._current || this._offset >= this._current.length) {
+                if (this._queue.length === 0) return written;
+                this._current = this._queue.shift();
+                this._offset = 0;
+            }
+            const avail = this._current.length - this._offset;
+            const n = Math.min(avail, count - written);
+            this._current.copy(buf, offset + written, this._offset, this._offset + n);
+            this._offset += n;
+            written += n;
+            if (this._offset >= this._current.length) this._current = null;
+        }
+        return written;
+    }
+
+    readSync(buffer, offset, count, waitMs = 30000) {
+        // Subscribe to the buffered queue so _recvLoop knows to retain
+        // payloads. Without an active sync reader the queue is intentionally
+        // not populated to avoid an unbounded retainer.
+        this._syncReaderActive = true;
+        const n = this._drain(buffer, offset, count);
+        if (n === count) {
+            if (this._queue.length === 0 && !this._current) this._syncReaderActive = false;
+            return n;
+        }
+        return new Promise((resolve, reject) => {
+            const deadline = Date.now() + waitMs;
+            const tick = () => {
+                const r = this._drain(buffer, offset, count);
+                if (r === count) {
+                    if (this._queue.length === 0 && !this._current) this._syncReaderActive = false;
+                    return resolve(r);
+                }
+                if (this._closed) {
+                    this._syncReaderActive = false;
+                    return reject(new Error('COTP stream closed'));
+                }
+                if (Date.now() > deadline) {
+                    this._syncReaderActive = false;
+                    return reject(new Error('Timeout waiting for COTP packet'));
+                }
+                setImmediate(tick);
+            };
+            this.once('packet', tick);
+            tick();
+        });
+    }
+
+    write(buffer) {
+        const packet = Buffer.alloc(ISO_HEADER_SIZE + buffer.length);
+        TPKT_COTP_HEADER.copy(packet, 0);
+        setWord(packet, 2, ISO_HEADER_SIZE + buffer.length);
+        buffer.copy(packet, ISO_HEADER_SIZE);
+        this._socket.write(packet);
+    }
+
+    end() {
+        this._closed = true;
+    }
+}
+
+/** Duplex adapter so tls.TLSSocket can run over COTP framing. */
+class CotpDuplex extends Duplex {
+    constructor(cotpStream) {
+        super();
+        this._cotp = cotpStream;
+        this._pending = [];
+        cotpStream.on('packet', (p) => {
+            this._pending.push(p);
+            this._readFromQueue();
+        });
+    }
+
+    _readFromQueue() {
+        while (this._pending.length) {
+            const p = this._pending.shift();
+            if (!this.push(p)) return;
+        }
+    }
+
+    _read() {
+        this._readFromQueue();
+    }
+
+    _write(chunk, _enc, cb) {
+        try {
+            this._cotp.write(chunk);
+            cb();
+        } catch (e) {
+            cb(e);
+        }
+    }
+
+    _final(cb) {
+        this._cotp.end();
+        cb();
+    }
+}
+
+module.exports = {
+    CotpStream,
+    CotpDuplex,
+    SocketReader,
+    readExactly,
+    disposeReader,
+    interruptReader,
+    getWord,
+    setWord,
+    ISO_HEADER_SIZE,
+    TPKT_COTP_HEADER
+};

package/node-red-contrib-s7-plus/lib/s7plus/transport/s7-transport.js

@@ -0,0 +1,335 @@
+'use strict';
+
+const net = require('net');
+const tls = require('tls');
+const { EventEmitter } = require('events');
+const {
+    CotpStream,
+    CotpDuplex,
+    readExactly,
+    disposeReader,
+    interruptReader,
+    getWord,
+    setWord,
+    ISO_HEADER_SIZE,
+    TPKT_COTP_HEADER
+} = require('./cotp-stream');
+const { S7Consts } = require('../constants');
+const { scoped } = require('../debug');
+const log = scoped('transport');
+
+const DEFAULT_PORT_ISO_TCP = 102;
+const ISO_CR_PREFIX = Buffer.from([
+    0x03, 0x00, 0x00, 0x24, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0x01, 0x00, 0xc0, 0x01, 0x0a,
+    0xc1, 0x02, 0x01, 0x00, 0xc2, 0x10
+]);
+
+class S7Transport extends EventEmitter {
+    constructor() {
+        super();
+        this._socket = null;
+        this._io = null;
+        this._cotp = null;
+        this._ssl = false;
+        this._recvBufs = [];
+        this._stopAfterNext = false;
+        this._recvRunning = false;
+        this._ip = '';
+        this._port = DEFAULT_PORT_ISO_TCP;
+        this._remoteTsap = null;
+        this._connTimeout = 10000;
+        this._recvTimeout = 10000;
+        this.lastError = 0;
+    }
+
+    setConnectionParams(address, _localTsap, remoteTsap, port) {
+        this._ip = address;
+        this._remoteTsap = Buffer.from(remoteTsap);
+        if (port && Number.isFinite(port) && port > 0) this._port = port;
+        else this._port = DEFAULT_PORT_ISO_TCP;
+        return 0;
+    }
+
+    setStopAfterNextPacket() {
+        this._stopAfterNext = true;
+    }
+
+    setTimeouts(ms) {
+        this._connTimeout = ms;
+        this._recvTimeout = ms;
+    }
+
+    _onPayload(payload) {
+        try {
+            this.emit('data', payload);
+        } catch (_) { /* ignore */ }
+        if (this._stopAfterNext) {
+            this._stopAfterNext = false;
+            this._plainRecv = false;
+        }
+    }
+
+    _startPlainRecv() {
+        if (this._recvRunning) return;
+        this._recvRunning = true;
+        const loop = async () => {
+            let exitReason = null;
+            while (this._plainRecv && this._socket && !this._socket.destroyed && !this._ssl) {
+                try {
+                    // Wait indefinitely for the next packet header.
+                    // The recv loop only runs during the brief pre-TLS
+                    // CC handshake phase, but even there an idle gap
+                    // must not be misread as a failure.
+                    const lenBuf = await readExactly(this._io, 4, 0);
+                    if (lenBuf[0] !== 0x03) continue;
+                    const total = getWord(lenBuf, 2);
+                    if (total <= ISO_HEADER_SIZE) continue;
+                    // Mid-packet: body must arrive within the configured
+                    // recv timeout.
+                    const rest = await readExactly(this._io, total - 4, this._recvTimeout);
+                    const pdu = Buffer.concat([lenBuf, rest]);
+                    const payloadLen = total - ISO_HEADER_SIZE;
+                    const payload = pdu.subarray(ISO_HEADER_SIZE, ISO_HEADER_SIZE + payloadLen);
+                    this._onPayload(payload);
+                } catch (err) {
+                    if (err && err.code === 'EREADINTERRUPTED' && !this._plainRecv) {
+                        // expected interrupt (e.g. switching to TLS)
+                        break;
+                    }
+                    // Real failure — record reason and surface to client.
+                    exitReason = `plain-recv: ${err && err.message ? err.message : err}`;
+                    log('plain recv loop terminated', { reason: exitReason });
+                    break;
+                }
+            }
+            this._recvRunning = false;
+            if (exitReason) {
+                try { this.emit('close', { kind: 'plain', reason: exitReason }); } catch { /* ignore */ }
+            }
+        };
+        this._plainRecvDone = loop();
+    }
+
+    connect() {
+        return new Promise((resolve) => {
+            this.lastError = 0;
+            if (!this._ip || !this._remoteTsap) {
+                this.lastError = S7Consts.errCliInvalidParams;
+                return resolve(this.lastError);
+            }
+
+            let settled = false;
+            const finish = (code) => {
+                if (settled) return;
+                settled = true;
+                clearTimeout(connectTimer);
+                this.lastError = code;
+                resolve(code);
+            };
+
+            log('connect tcp', { host: this._ip, port: this._port, connTimeout: this._connTimeout });
+            const sock = net.connect({ host: this._ip, port: this._port });
+            sock.setNoDelay(true);
+            sock.setKeepAlive(true, 15000);
+
+            const connectTimer = setTimeout(() => {
+                log('connect tcp timeout', { host: this._ip, port: this._port });
+                try { sock.destroy(); } catch { /* ignore */ }
+                finish(S7Consts.errTCPConnectionTimeout);
+            }, this._connTimeout);
+
+            sock.once('error', (err) => {
+                log('connect tcp error', { msg: err && err.message });
+                finish(S7Consts.errTCPConnectionFailed);
+            });
+
+            sock.once('connect', async () => {
+                clearTimeout(connectTimer);
+                log('tcp established', { host: this._ip, port: this._port });
+                this._socket = sock;
+                this._io = sock;
+                this._installSocketWatch(sock, 'plain');
+                try {
+                    const cr = Buffer.alloc(20 + this._remoteTsap.length);
+                    ISO_CR_PREFIX.copy(cr, 0, 0, 20);
+                    this._remoteTsap.copy(cr, 20);
+                    setWord(cr, 2, 20 + this._remoteTsap.length);
+                    cr[4] = 15 + this._remoteTsap.length;
+                    cr[19] = this._remoteTsap.length;
+                    sock.write(cr);
+                    const ccHdr = await readExactly(sock, 4, this._connTimeout);
+                    if (!ccHdr || ccHdr[0] !== 0x03) {
+                        return finish(S7Consts.errIsoConnect);
+                    }
+                    const ccTotal = getWord(ccHdr, 2);
+                    if (ccTotal < ISO_HEADER_SIZE) {
+                        return finish(S7Consts.errIsoConnect);
+                    }
+                    const ccBody = await readExactly(sock, ccTotal - 4, this._connTimeout);
+                    if (!ccBody || ccBody[1] !== 0xd0) {
+                        return finish(S7Consts.errIsoConnect);
+                    }
+                    this._plainRecv = true;
+                    this._startPlainRecv();
+                    if (!settled) {
+                        settled = true;
+                        resolve(0);
+                    }
+                } catch {
+                    finish(S7Consts.errIsoConnect);
+                }
+            });
+        });
+    }
+
+    async sslActivate() {
+        if (!this._socket) {
+            this.lastError = S7Consts.errOpenSSL;
+            return this.lastError;
+        }
+        // Stop the plain receive loop cleanly: signal exit and interrupt the
+        // pending readExactly so the loop does not race with the upcoming
+        // CotpStream._recvLoop (both share the same SocketReader).
+        this._plainRecv = false;
+        interruptReader(this._socket, 'switching to TLS');
+        if (this._plainRecvDone) {
+            try { await this._plainRecvDone; } catch { /* ignore */ }
+        }
+
+        return new Promise((resolve) => {
+            try {
+                const cotp = new CotpStream(this._socket, this._recvTimeout);
+                this._cotp = cotp;
+                const duplex = new CotpDuplex(cotp);
+                // tls.connect (NOT new tls.TLSSocket) actually drives the
+                // handshake by sending ClientHello on the underlying duplex.
+                // S7-1500 only supports TLS 1.3, and the negotiated COTP TPDU
+                // size is 1024 bytes - default Node.js offers many key share
+                // groups (~1450 byte ClientHello) which the PLC silently drops.
+                // Restrict to X25519 so the ClientHello stays around 224 bytes
+                // and comfortably fits a single TPKT/COTP frame.
+                const secure = tls.connect({
+                    socket: duplex,
+                    minVersion: 'TLSv1.3',
+                    maxVersion: 'TLSv1.3',
+                    ecdhCurve: 'X25519',
+                    rejectUnauthorized: false
+                });
+                let settled = false;
+                // Hard bound the handshake. Without this, a PLC that
+                // accepts the TCP connection but never sends ServerHello
+                // (firmware update, half-broken state) would block
+                // sslActivate forever.
+                const sslTimer = setTimeout(() => {
+                    if (settled) return;
+                    settled = true;
+                    log('ssl handshake timeout', { timeoutMs: this._connTimeout });
+                    this.lastError = S7Consts.errOpenSSL;
+                    this._tlsError = new Error(`SSL handshake timeout (${this._connTimeout}ms)`);
+                    try { secure.destroy(); } catch { /* ignore */ }
+                    resolve(this.lastError);
+                }, this._connTimeout);
+                secure.once('secureConnect', () => {
+                    if (settled) return;
+                    settled = true;
+                    clearTimeout(sslTimer);
+                    this._ssl = true;
+                    this._tlsSocket = secure;
+                    this._io = secure;
+                    this._recvRunning = true;
+                    secure.on('data', (chunk) => this._onPayload(chunk));
+                    this._installSocketWatch(secure, 'tls');
+                    resolve(0);
+                });
+                secure.once('error', (e) => {
+                    if (settled) return;
+                    settled = true;
+                    clearTimeout(sslTimer);
+                    this.lastError = S7Consts.errOpenSSL;
+                    this._tlsError = e;
+                    resolve(this.lastError);
+                });
+            } catch (e) {
+                this.lastError = S7Consts.errOpenSSL;
+                this._tlsError = e;
+                resolve(this.lastError);
+            }
+        });
+    }
+
+    /**
+     * Write a packet to the underlying socket. All failure modes throw
+     * so the caller learns immediately — a silent "write disappeared"
+     * would leave the request waiter sitting around until its read
+     * timeout fires, hiding the real cause.
+     */
+    send(packet) {
+        if (!this._io) {
+            this.lastError = S7Consts.errTCPNotConnected;
+            throw new Error('Send failed: client not connected');
+        }
+        this.lastError = 0;
+        try {
+            if (this._ssl) {
+                this._tlsSocket.write(packet);
+            } else {
+                const packetLen = ISO_HEADER_SIZE + packet.length;
+                const out = Buffer.alloc(packetLen);
+                TPKT_COTP_HEADER.copy(out, 0);
+                setWord(out, 2, packetLen);
+                packet.copy(out, ISO_HEADER_SIZE);
+                this._io.write(out);
+            }
+        } catch (err) {
+            this.lastError = S7Consts.errTCPDataSend;
+            throw new Error(`Send failed: ${err && err.message ? err.message : err}`);
+        }
+    }
+
+    disconnect() {
+        if (!this._socket && !this._io && !this._tlsSocket) {
+            return 0;
+        }
+        log('disconnect', { hadSocket: !!this._socket, hadTls: !!this._tlsSocket });
+        this._recvRunning = false;
+        this._plainRecv = false;
+        try {
+            if (this._cotp) this._cotp.end();
+            if (this._socket) {
+                disposeReader(this._socket);
+                this._socket.destroy();
+            }
+        } catch { /* ignore */ }
+        this._socket = null;
+        this._io = null;
+        this._tlsSocket = null;
+        this._cotp = null;
+        this._ssl = false;
+        return 0;
+    }
+
+    /**
+     * Watch the raw or TLS socket for close/error/end and surface a single
+     * 'close' event so the client can flip its `_connected` flag and reject
+     * pending PDU waiters instead of hanging until the read timeout fires.
+     */
+    _installSocketWatch(sock, kind) {
+        if (!sock || sock._s7pClosedWatch) return;
+        sock._s7pClosedWatch = true;
+        const fire = (reason) => {
+            if (sock._s7pCloseFired) return;
+            sock._s7pCloseFired = true;
+            log('socket close-event', { kind, reason });
+            try { this.emit('close', { kind, reason }); } catch { /* ignore */ }
+        };
+        sock.once('close', () => fire('socket-close'));
+        sock.once('end', () => fire('socket-end'));
+        sock.once('error', (err) => fire(`socket-error: ${err && err.message ? err.message : err}`));
+    }
+
+    get connected() {
+        return this._socket && !this._socket.destroyed;
+    }
+}
+
+module.exports = S7Transport;