node-red-contrib-ntrip 0.2.3 → 0.2.7

package/ntrip/nodes/ntrip-client-node.js

@@ -1,158 +1,178 @@
 module.exports = function (RED) {
     'use strict';
 
-    const NtripClient = require("../lib/ntrip-client.js");
+    const NtripClient = require('../lib/ntrip-client.js');
     const NtripServerOkReply = 'ICY 200 OK';
     const NtripServerNotOkReply = 'ICY 406';
     const NtripServerMissingMountpoint = 'SOURCETABLE 200 OK';
+    const HandshakePrefixBytes = 64;
 
     function NtripClientNode(config) {
         RED.nodes.createNode(this, config);
         let node = this;
         node.messagesReceived = 0;
+        node.messagesSent = 0;
         node.passthrough = config.passthrough || false;
-        
-        let host = config.host;
-        let port = config.port || 2101;
+
+        let host = typeof config.host === 'string' ? config.host.trim() : '';
+        let port = parseInt(config.port, 10) || 2101;
         let mountpoint = config.mountpoint;
         let mode = config.mode || 'download';
         let authmode = config.authmode || 'legacy';
-        
+        let interval = parseInt(config.interval, 10) || 1000;
+
+        if (host === '') {
+            node.status({ fill: 'red', shape: 'ring', text: 'Host not configured' });
+            return;
+        }
+
+        let options = {
+            host: host,
+            port: port,
+            mountpoint: mountpoint,
+            username: node.credentials.username,
+            password: node.credentials.password,
+            interval: interval,
+        };
+
+        // Depending on the caster the clients need to provide the location via GGA sentence.
+        let x = parseFloat(config.xcoordinate);
+        let y = parseFloat(config.ycoordinate);
+        let z = parseFloat(config.zcoordinate);
+
+        if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z) && !(x === 0 && y === 0 && z === 0)) {
+            options.xyz = [x, y, z];
+        }
+
         let client;
-        if(host !== undefined ) {
-
-            let options = {
-                host: host,
-                port: port,
-                mountpoint: mountpoint,
-                username: node.credentials.username,
-                password: node.credentials.password,
-                interval: config.interval,
-            };
-
-            // Depending on the caster the clients need to provide the location via GGA sentence.
-            let x = parseFloat(config.xcoordinate || 0);
-            let y = parseFloat(config.ycoordinate || 0);
-            let z = parseFloat(config.zcoordinate || 0);
-            
-            if (x !== 0 && y !== 0 && z !== 0) {
-                options.xyz = [x, y, z];
-            }
-            
-            if (mode === 'download') {
-                // Clients only consume ntrip data.
-                client = NtripClient.createDownloader(options);
-            }
-            else  if (mode === 'upload') {
-                // Uploaders send RTCM data to a mountpoint so that clients can consume it.
-                options.authmode = authmode;
+        if (mode === 'download') {
+            client = NtripClient.createDownloader(options);
+        } else if (mode === 'upload') {
+            options.authmode = authmode;
+            try {
                 client = NtripClient.createUploader(options);
+            } catch (error) {
+                node.status({ fill: 'red', shape: 'ring', text: String(error.message || error) });
+                node.error('Failed to create uploader: ' + (error.message || error));
+                return;
             }
-            else {
-                node.error('Mode not supported ' + mode);
-            }
+        } else {
+            node.status({ fill: 'red', shape: 'ring', text: 'Unsupported mode: ' + mode });
+            node.error('Mode not supported: ' + mode);
+            return;
+        }
 
-            client.on('data', (data) => {
-                node.messagesReceived++;
-                node.status({
-                    fill: 'green',
-                    shape: 'ring',
-                    text: 'Messages ' + node.messagesReceived,
-                });
+        // Track handshake state so we only intercept control replies during the handshake,
+        // not on every subsequent data packet. Reset on socket close so reconnects work.
+        let connected = false;
 
-                let msg = {
-                    payload : data
-                }
+        function updateStatus() {
+            node.status({
+                fill: 'green',
+                shape: 'ring',
+                text: 'Rx ' + node.messagesReceived + ' Tx ' + node.messagesSent,
+            });
+        }
 
-                // check if ICY 200 OK
-                const response = data.toString();
-                if (response.startsWith(NtripServerOkReply)) {
-                    node.status({
-                        fill: 'green',
-                        shape: 'ring',
-                        text: 'NTRIP server connected.',
-                    }); 
+        client.on('data', (data) => {
+            if (!connected) {
+                let prefix = data.toString('utf8', 0, Math.min(data.length, HandshakePrefixBytes));
+                if (prefix.startsWith(NtripServerOkReply)) {
+                    connected = true;
+                    node.status({ fill: 'green', shape: 'ring', text: 'NTRIP server connected.' });
+                    // Forward any RTCM bytes that arrived in the same TCP segment as the handshake reply.
+                    let headerEnd = data.indexOf('\r\n\r\n');
+                    if (headerEnd !== -1 && headerEnd + 4 < data.length) {
+                        node.messagesReceived++;
+                        node.send({ payload: data.slice(headerEnd + 4) });
+                        updateStatus();
+                    }
+                    return;
                 }
-                // check if ICY 406 Not Acceptable
-                else if (response.startsWith(NtripServerNotOkReply)) {
-                    node.status({
-                        fill: 'red',
-                        shape: 'ring',
-                        text: 'NTRIP server rejected connection.',
-                    }); 
-                    node.error('Server rejected connect: ' + response); 
-                } 
-                else if (response.startsWith(NtripServerMissingMountpoint)) {
-                    node.status({
-                        fill: 'red',
-                        shape: 'ring',
-                        text: 'No mountpont ' + mountpoint,
-                    });
-                    node.error('No mountpoint: ' + response); 
+                if (prefix.startsWith(NtripServerNotOkReply)) {
+                    node.status({ fill: 'red', shape: 'ring', text: 'NTRIP server rejected connection.' });
+                    node.error('Server rejected connect: ' + prefix);
+                    return;
                 }
-                else {
-                    node.send(msg);    
+                if (prefix.startsWith(NtripServerMissingMountpoint)) {
+                    node.status({ fill: 'red', shape: 'ring', text: 'No mountpoint ' + mountpoint });
+                    node.error('No mountpoint: ' + prefix);
+                    return;
                 }
-            });
+                // Unexpected: data arrived before any recognised handshake reply.
+                // Treat as connected so we don't drop further frames.
+                connected = true;
+            }
 
-            client.on('close', () => {
-                node.log('Closed NTRIP connection.');
-            });
+            node.messagesReceived++;
+            node.send({ payload: data });
+            updateStatus();
+        });
 
-            client.on('error', (error) => {
-                if (error instanceof AggregateError) {
-                    error.errors.forEach((e, i) => {
-                        node.log(`Error ${i + 1}: ${e.message}`);
-                        node.error('Error: ' + e.message);
-                    });
-                } else {
-                    node.log(error);
-                    node.error('Error: ' + error);
-                }
-            });
+        client.on('close', () => {
+            connected = false;
+            node.log('Closed NTRIP connection.');
+        });
 
+        client.on('error', (error) => {
+            connected = false;
+            if (typeof AggregateError !== 'undefined' && error instanceof AggregateError) {
+                error.errors.forEach((e, i) => {
+                    node.log('Error ' + (i + 1) + ': ' + e.message);
+                    node.error('Error: ' + e.message);
+                });
+            } else {
+                let text = error && error.message ? error.message : String(error);
+                node.log(text);
+                node.error('Error: ' + text);
+            }
+        });
+
+        try {
             client.run();
-            node.status({
-                fill: 'green',
-                shape: 'ring',
-                text: 'ok',
-            });
+        } catch (error) {
+            node.status({ fill: 'red', shape: 'ring', text: String(error.message || error) });
+            node.error('Failed to start client: ' + (error.message || error));
+            return;
+        }
+
+        node.status({ fill: 'yellow', shape: 'ring', text: 'connecting...' });
+
+        this.on('input', function (msg) {
+            let payload = msg.payload;
+            if (payload === undefined || payload === null) {
+                return;
+            }
 
-            this.on('input', async function (msg) {
-                if (msg.payload) {
-                    node.messagesReceived++;
-                    node.status({
-                        fill: 'green',
-                        shape: 'ring',
-                        text: 'Messages ' + node.messagesReceived,
-                    });
-
-                    try {
-                        let data = msg.payload;
-                        if (Array.isArray(data)) {
-                            client.setXYZ(data);
-                        } 
-                        else {
-                            client.write(data);
-
-                            if(node.passthrough) {
-                                node.send(msg);
-                            }
-                        }
-                    } catch (error) {
-                        node.status({ fill: 'red', shape: 'ring', text: error });
-                        node.error('Failed to write data: ' + error, error);
+            try {
+                if (Array.isArray(payload)) {
+                    client.setXYZ(payload);
+                } else {
+                    client.write(payload);
+                    node.messagesSent++;
+                    if (node.passthrough) {
+                        node.send(msg);
                     }
+                    updateStatus();
                 }
-            });
+            } catch (error) {
+                let text = error && error.message ? error.message : String(error);
+                node.status({ fill: 'red', shape: 'ring', text: text });
+                node.error('Failed to write data: ' + text, msg);
+            }
+        });
 
-            this.on('close', function(done) {
+        this.on('close', function (done) {
+            try {
+                client.removeAllListeners();
                 client.close();
-                node.status({});
-                done();
-            });
-        }
+            } catch {
+                // ignore — node is shutting down anyway
+            }
+            node.status({});
+            done();
+        });
     }
-    
+
     return NtripClientNode;
-};
+};

package/ntrip/nodes/rtcm-decoder-node.js

@@ -1,71 +1,89 @@
 module.exports = function (RED) {
     'use strict';
 
-    const { RtcmTransport, RtcmMessage, RtcmMessageType } = require('@gnss/rtcm');
-   
+    const { RtcmTransport } = require('@gnss/rtcm');
+
+    // Cap on pending bytes when a decode keeps failing — guards against runaway memory
+    // if upstream feeds us garbage rather than truly-partial RTCM frames.
+    const MaxPendingBytes = 65536;
+
     function RtcmDecoderNode(config) {
         RED.nodes.createNode(this, config);
         let node = this;
         node.rtcmMessagesReceived = 0;
         node.invalidMessagesReceived = 0;
+        node.pendingBuffer = Buffer.alloc(0);
+
+        function updateStatus() {
+            node.status({
+                fill: 'green',
+                shape: 'ring',
+                text: 'RTCM: ' + node.rtcmMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
+            });
+        }
 
         this.on('input', function (msg) {
+            if (msg.payload === undefined || msg.payload === null) {
+                return;
+            }
 
-            let done = false;
-            let buffer = msg.payload;
-            try
-            {
-                do {
-                    let message;
-                    let length;
-                    [message, length] = RtcmTransport.decode(buffer);     
-                    
-                    let messageType = message.constructor.name.replace('RtcmMessage', '');
+            let chunk = Buffer.isBuffer(msg.payload) ? msg.payload : Buffer.from(msg.payload);
+            let buffer = node.pendingBuffer.length > 0 ? Buffer.concat([node.pendingBuffer, chunk]) : chunk;
 
-                    let msg = {
-                        payload : {
-                            rtcm : message.messageType,
-                            messageType : messageType,
-                            message : message,
-                            input : buffer
-                        }
-                    };
+            while (buffer.length > 0) {
+                let message;
+                let length;
+                try {
+                    [message, length] = RtcmTransport.decode(buffer);
+                } catch (ex) {
+                    // Likely a partial frame at the tail of this chunk — keep the bytes
+                    // for the next input event. If we've accumulated too much without a
+                    // successful decode, drop and emit an error.
+                    if (buffer.length > MaxPendingBytes) {
+                        let errMsg = {
+                            payload: {
+                                error: ex,
+                                input: buffer,
+                                inputString: buffer.toString(),
+                            },
+                        };
+                        node.send([null, errMsg]);
+                        node.invalidMessagesReceived++;
+                        buffer = Buffer.alloc(0);
+                    }
+                    break;
+                }
 
-                    node.send([msg, null]);
-                    node.rtcmMessagesReceived++;
+                if (!Number.isInteger(length) || length <= 0 || length > buffer.length) {
+                    // Defensive — guarantees forward progress even if the decoder ever
+                    // returns a non-positive length.
+                    break;
+                }
 
-                    // find next message in buffer.
-                    buffer = buffer.slice(length);
-                    if(buffer.length == 0){
-                        done = true;
-                    }
-                } while(!done);
-            }
-            catch(ex)
-            {
-                let msg = {
-                    payload : {
-                        error : ex,
-                        input : buffer,
-                        inputString : buffer.toString()
-                    }
+                let messageType = message.constructor.name.replace('RtcmMessage', '');
+                let outMsg = {
+                    payload: {
+                        rtcm: message.messageType,
+                        messageType: messageType,
+                        message: message,
+                        input: buffer.slice(0, length),
+                    },
                 };
-                node.send([null, msg]);
-                node.invalidMessagesReceived++;
+                node.send([outMsg, null]);
+                node.rtcmMessagesReceived++;
+                buffer = buffer.slice(length);
             }
 
-            node.status({
-                fill: 'green',
-                    shape: 'ring',
-                    text: 'RTCM: ' + node.rtcmMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
-                });
+            node.pendingBuffer = buffer;
+            updateStatus();
         });
 
-        this.on('close', function(done) {
+        this.on('close', function (done) {
+            node.pendingBuffer = Buffer.alloc(0);
             node.status({});
             done();
         });
     }
-    
+
     return RtcmDecoderNode;
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ntrip",
-    "version": "0.2.3",
+    "version": "0.2.7",
     "description": "Node for ntrip and rtcm handling.",
     "node-red": {
         "version": ">=0.1.0",
@@ -9,7 +9,7 @@
         }
     },
     "engines": {
-        "node": ">=7.6.0"
+        "node": ">=18.0.0"
     },
     "keywords": [
         "node-red",
@@ -24,9 +24,27 @@
     },
     "author": "Karl-Heinz Wind",
     "license": "MIT",
+    "scripts": {
+        "test": "mocha test/**/*.spec.js --timeout 5000",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "format": "prettier --write .",
+        "format:check": "prettier --check ."
+    },
     "dependencies": {
         "@gnss/nmea": "^0.1.2",
         "@gnss/rtcm": "^0.1.5",
         "ntrip-client": "^1.1.1"
+    },
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "chai": "^4.5.0",
+        "eslint": "^10.3.0",
+        "eslint-config-prettier": "^10.1.8",
+        "globals": "^17.6.0",
+        "mocha": "^11.7.5",
+        "node-red": "^4.1.10",
+        "node-red-node-test-helper": "^0.3.6",
+        "prettier": "^3.8.3"
     }
 }

package/test/nmea-decoder.spec.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const helper = require('node-red-node-test-helper');
+const { expect } = require('chai');
+const ntripModule = require('../ntrip/99-ntrip.js');
+
+helper.init(require.resolve('node-red'));
+
+const GGA = '$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47';
+const GLL = '$GPGLL,4916.45,N,12311.12,W,225444,A,*1D';
+
+function flow() {
+    return [
+        { id: 'n1', type: 'NmeaDecoder', wires: [['ok'], ['err']] },
+        { id: 'ok', type: 'helper' },
+        { id: 'err', type: 'helper' },
+    ];
+}
+
+describe('NmeaDecoder', function () {
+    before(() => helper.startServer());
+    after(() => helper.stopServer());
+    afterEach(() => helper.unload());
+
+    it('decodes a valid GGA sentence on the success output', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.messageType).to.equal('GGA');
+                        expect(msg.payload.nmeaMessage).to.have.property('latitude');
+                        expect(msg.payload.input).to.equal(GGA);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: GGA });
+            });
+        });
+    });
+
+    it('splits a multi-sentence chunk into separate output messages', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                const types = [];
+                ok.on('input', (msg) => {
+                    types.push(msg.payload.messageType);
+                    if (types.length === 2) {
+                        try {
+                            expect(types).to.deep.equal(['GGA', 'GLL']);
+                            resolve();
+                        } catch (e) {
+                            reject(e);
+                        }
+                    }
+                });
+                n1.receive({ payload: GGA + '\r\n' + GLL + '\r\n' });
+            });
+        });
+    });
+
+    it('accepts a Buffer payload and decodes it as UTF-8', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.messageType).to.equal('GGA');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: Buffer.from(GGA, 'utf8') });
+            });
+        });
+    });
+
+    it('reads payload.nmeaMessage when payload is an object', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const ok = helper.getNode('ok');
+                ok.on('input', (msg) => {
+                    try {
+                        expect(msg.payload.messageType).to.equal('GGA');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: { nmeaMessage: GGA } });
+            });
+        });
+    });
+
+    it('error output preserves Buffer input as `input`, utf8 as `inputString`', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                const err = helper.getNode('err');
+                const garbage = Buffer.from([0xd3, 0x00, 0x13, 0x3e, 0xd0, 0x00]);
+                err.on('input', (msg) => {
+                    try {
+                        expect(Buffer.isBuffer(msg.payload.input)).to.equal(true);
+                        expect(msg.payload.input).to.deep.equal(garbage);
+                        expect(msg.payload.inputString).to.be.a('string');
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+                n1.receive({ payload: garbage });
+            });
+        });
+    });
+
+    it('does not call node.error on decode failure (regression: log flood)', function () {
+        return new Promise((resolve, reject) => {
+            helper.load(ntripModule, flow(), () => {
+                const n1 = helper.getNode('n1');
+                let errorCalled = false;
+                const originalError = n1.error.bind(n1);
+                n1.error = function (...args) {
+                    errorCalled = true;
+                    return originalError(...args);
+                };
+                n1.receive({ payload: Buffer.from([0xd3, 0x00, 0x13, 0x3e]) });
+                setTimeout(() => {
+                    try {
+                        expect(errorCalled).to.equal(false);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
+                }, 50);
+            });
+        });
+    });
+});