node-red-contrib-ntrip 0.2.3 → 0.2.7

package/ntrip/lib/ntrip-client.js

@@ -6,9 +6,18 @@ const net = require('net');
 
 // Orginal class is extended to be able to send data to the caster.
 class NtripClientUploader extends NtripClient {
-    constructor(options) {  
+    constructor(options) {
         super(options);
         this.authmode = options.authmode || 'legacy';
+
+        // Reject CR/LF in user-supplied fields that are interpolated into the
+        // handshake string, to prevent header injection.
+        for (const field of ['mountpoint', 'username', 'password']) {
+            const value = this[field];
+            if (typeof value === 'string' && /[\r\n]/.test(value)) {
+                throw new Error('Invalid character in ' + field + ': CR/LF not allowed');
+            }
+        }
     }
 
     _connect() {
@@ -19,12 +28,12 @@ class NtripClientUploader extends NtripClient {
         // init connection of client
         this.client = net.createConnection({
             host: this.host,
-            port: this.port
+            port: this.port,
         });
 
         // on timeout event
         this.client.on('timeout', () => {
-            this._onError('socket timeouted');
+            this._onError('socket timeout');
         });
 
         // on connect event
@@ -36,23 +45,19 @@ class NtripClientUploader extends NtripClient {
             const host = this.host;
             const port = this.port;
             const authmode = this.authmode;
-            const authorization = Buffer.from(
-                username + ':' + password,
-                'utf8'
-            ).toString('base64');
-        
+            const authorization = Buffer.from(username + ':' + password, 'utf8').toString('base64');
+
             let data;
             switch (authmode) {
-                case 'legacy': // Legacy --> rtk2Go accepts this. 
+                case 'legacy': // Legacy --> rtk2Go accepts this.
                     if (username === '' && password === '') {
                         data = `SOURCE ${mountpoint}\r\n\r\n`;
-                    }
-                    else {
-                        data = `SOURCE ${password} /${mountpoint}\r\nSource-Agent: NTRIP ${username}\r\n\r\n`;     
+                    } else {
+                        data = `SOURCE ${password} /${mountpoint}\r\nSource-Agent: NTRIP ${username}\r\n\r\n`;
                     }
                     break;
                 case 'hybrid': // hybrid (legacy + http auth) --> SNIP accepts this.
-                    data = `SOURCE ${mountpoint}\r\nAuthorization: Basic ${authorization}\r\n\r\n`;      
+                    data = `SOURCE ${mountpoint}\r\nAuthorization: Basic ${authorization}\r\n\r\n`;
                     break;
                 case 'ntripv1': // NTRIP V1 POST
                     data = `POST /${mountpoint} HTTP/1.0\r\nUser-Agent: NTRIP ${userAgent}\r\nAuthorization: Basic ${authorization}\r\nContent-Type: gnss/data\r\n\r\n`;
@@ -61,7 +66,7 @@ class NtripClientUploader extends NtripClient {
                     data = `POST /${mountpoint} HTTP/1.1\r\nHost: ${host}:${port}\r\nUser-Agent: NTRIP ${userAgent}\r\nAuthorization: Basic ${authorization}\r\nNtrip-Version: Ntrip/2.0\r\nContent-Type: gnss/data\r\nConnection: keep-alive\r\n\r\n`;
                     break;
                 default:
-                    throw new Error("Auth mode is not supported " + authmode);
+                    throw new Error('Auth mode is not supported ' + authmode);
             }
 
             this.client.write(data);
@@ -93,14 +98,14 @@ class NtripClientUploader extends NtripClient {
 }
 
 function createDownloader(options) {
-    return new NtripClient(options)
+    return new NtripClient(options);
 }
 
 function createUploader(options) {
-    return new NtripClientUploader(options)
+    return new NtripClientUploader(options);
 }
 
 module.exports = {
     createDownloader,
-    createUploader
-};
+    createUploader,
+};

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

@@ -9,54 +9,97 @@ module.exports = function (RED) {
         node.nmeaMessagesReceived = 0;
         node.invalidMessagesReceived = 0;
 
-        this.on('input', function (msg) {
+        function updateStatus() {
+            node.status({
+                fill: 'green',
+                shape: 'ring',
+                text: 'NMEA: ' + node.nmeaMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
+            });
+        }
 
-            let buffer = msg.payload.nmeaMessage ?? msg.payload;
-            if(Buffer.isBuffer(buffer)){
-                buffer = buffer.toString('utf8');
-            }
-            
-            try
-            {   
-                let nmeaMessage = NmeaTransport.decode(buffer);   
+        function decodeOne(sentence, rawInput, rawString) {
+            try {
+                let nmeaMessage = NmeaTransport.decode(sentence);
                 let messageType = nmeaMessage.constructor.name.replace('NmeaMessage', '').toUpperCase();
 
-                let msg = {
-                    payload : {
-                        messageType : messageType,
-                        nmeaMessage : nmeaMessage,   
-                        input : buffer
+                node.send([
+                    {
+                        payload: {
+                            messageType: messageType,
+                            nmeaMessage: nmeaMessage,
+                            input: sentence,
+                        },
                     },
-                };
-
-                node.send([msg, null]);
+                    null,
+                ]);
                 node.nmeaMessagesReceived++;
+            } catch (ex) {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: ex,
+                            input: rawInput,
+                            inputString: rawString,
+                        },
+                    },
+                ]);
+                node.invalidMessagesReceived++;
+            }
+        }
+
+        this.on('input', function (msg) {
+            if (msg.payload === undefined || msg.payload === null) {
+                return;
             }
-            catch(ex)
-            {
-                let msg = {
-                    payload : {
-                        error : ex,
-                        input : buffer,
-                        inputString : buffer.toString()
-                    }
-                };
-                node.send([null, msg]);
+
+            // rawInput is the value the user provided (Buffer, string, ...).
+            // Keep it untouched so the error output can return it as-is.
+            let rawInput = typeof msg.payload === 'object' && msg.payload.nmeaMessage !== undefined ? msg.payload.nmeaMessage : msg.payload;
+
+            let rawString;
+            if (Buffer.isBuffer(rawInput)) {
+                rawString = rawInput.toString('utf8');
+            } else if (typeof rawInput === 'string') {
+                rawString = rawInput;
+            } else {
+                node.send([
+                    null,
+                    {
+                        payload: {
+                            error: 'Payload is neither string nor Buffer',
+                            input: rawInput,
+                            inputString: String(rawInput),
+                        },
+                    },
+                ]);
                 node.invalidMessagesReceived++;
+                updateStatus();
+                return;
             }
 
-            node.status({
-                fill: 'green',
-                    shape: 'ring',
-                    text: 'NMEA: ' + node.nmeaMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
-                });
+            // A single chunk may carry several sentences delimited by \r\n.
+            let sentences = rawString.split(/\r?\n/);
+            let any = false;
+            for (let i = 0; i < sentences.length; i++) {
+                let s = sentences[i].trim();
+                if (s.length === 0) {
+                    continue;
+                }
+                decodeOne(s, rawInput, rawString);
+                any = true;
+            }
+
+            if (any) {
+                updateStatus();
+            }
         });
 
-        this.on('close', function(done) {
+        this.on('close', function (done) {
             node.status({});
             done();
         });
     }
 
     return NmeaDecoderNode;
-};
+};

package/ntrip/nodes/nmea-encoder-node.js

@@ -1,16 +1,16 @@
 module.exports = function (RED) {
     'use strict';
 
-    const { 
-        NmeaTransport, 
+    const {
+        NmeaTransport,
         NmeaMessageUnknown,
         NmeaMessage,
         NmeaMessageDtm,
         NmeaMessageGbs,
         NmeaMessageGga,
         NmeaMessageGll,
-        NmeaMessageGns, 
-        NmeaMessageGrs, 
+        NmeaMessageGns,
+        NmeaMessageGrs,
         NmeaMessageGsa,
         NmeaMessageGst,
         NmeaMessageGsv,
@@ -30,24 +30,53 @@ module.exports = function (RED) {
         node.nmeaMessagesReceived = 0;
         node.invalidMessagesReceived = 0;
 
+        function updateStatus(ok) {
+            node.status({
+                fill: ok ? 'green' : 'red',
+                shape: 'ring',
+                text: 'NMEA: ' + node.nmeaMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
+            });
+        }
+
+        function safeToString(value) {
+            if (value === undefined || value === null) {
+                return '';
+            }
+            try {
+                return String(value);
+            } catch {
+                return '';
+            }
+        }
+
         this.on('input', function (msg) {
+            let payload = msg.payload;
+
+            if (payload == null || payload.nmeaMessage == null || payload.messageType == null) {
+                let errMsg = {
+                    payload: {
+                        error: 'Invalid input. Expected payload with nmeaMessage and messageType properties.',
+                        input: payload,
+                        inputString: safeToString(payload),
+                    },
+                };
+                node.send([null, errMsg]);
+                node.invalidMessagesReceived++;
+                updateStatus(false);
+                return;
+            }
+
+            let input = payload.nmeaMessage;
+
+            try {
+                let messageType = String(payload.messageType).toUpperCase();
 
-            let input = msg.payload.nmeaMessage;
-            let isNmeaMessage = input.prototype instanceof NmeaMessage; 
-            let messageType = msg.payload.messageType;
-            messageType = messageType.toUpperCase();
-                   
-            try
-            {
-                let message;
                 let nmeaMessage;
-                if(isNmeaMessage){
-                    nmeaMessage = input; // is already a NmeaMessage
-                }
-                else {
-                    
+                if (input instanceof NmeaMessage) {
+                    nmeaMessage = input;
+                } else {
                     switch (messageType) {
-                        case 'Object':
+                        case 'OBJECT':
                             nmeaMessage = NmeaMessageUnknown.construct(input);
                             break;
                         case 'DTM':
@@ -102,50 +131,42 @@ module.exports = function (RED) {
                             nmeaMessage = NmeaMessageZda.construct(input);
                             break;
                         default:
-                            // message could not be converted.
-                            break;
+                            throw new Error('Unsupported NMEA message type: ' + messageType);
                     }
                 }
 
-                if (nmeaMessage !== undefined) {
-                    message = NmeaTransport.encode(nmeaMessage); 
-                }
-                
-                let msg = {
-                    payload : {
-                        nmeaMessage : message,   
-                        input : input
+                let message = NmeaTransport.encode(nmeaMessage);
+
+                let outMsg = {
+                    payload: {
+                        nmeaMessage: message,
+                        messageType: payload.messageType,
+                        input: input,
                     },
                 };
 
-                node.send([msg, null]);
+                node.send([outMsg, null]);
                 node.nmeaMessagesReceived++;
-            }
-            catch(ex)
-            {
-                let msg = {
-                    payload : {
-                        error : ex,
-                        input : input,
-                        inputString : input.toString()
-                    }
+                updateStatus(true);
+            } catch (ex) {
+                let errMsg = {
+                    payload: {
+                        error: ex,
+                        input: input,
+                        inputString: safeToString(input),
+                    },
                 };
-                node.send([null, msg]);
+                node.send([null, errMsg]);
                 node.invalidMessagesReceived++;
+                updateStatus(false);
             }
-
-            node.status({
-                fill: 'green',
-                    shape: 'ring',
-                    text: 'NMEA: ' + node.nmeaMessagesReceived + ' Invalid: ' + node.invalidMessagesReceived,
-                });
         });
 
-        this.on('close', function(done) {
+        this.on('close', function (done) {
             node.status({});
             done();
         });
     }
 
     return NmeaEncoderNode;
-};
+};