node-opcua-transport 2.167.0 → 2.169.0

package/source/client_tcp_transport.ts

@@ -1,22 +1,22 @@
 /**
  * @module node-opcua-transport
  */
-import os from "os";
-import { createConnection } from "net";
-import { types } from "util";
+
+import { createConnection } from "node:net";
+import os from "node:os";
+import { types } from "node:util";
 import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
 import { BinaryStream } from "node-opcua-binary-stream";
 import { readMessageHeader } from "node-opcua-chunkmanager";
-import { ErrorCallback } from "node-opcua-status-code";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
-import { getFakeTransport, ISocketLike, TCP_transport } from "./tcp_transport";
-import { decodeMessage, packTcpMessage, parseEndpointUrl } from "./tools";
-
+import type { ErrorCallback } from "node-opcua-status-code";
 import { AcknowledgeMessage } from "./AcknowledgeMessage";
 import { HelloMessage } from "./HelloMessage";
 import { TCPErrorMessage } from "./TCPErrorMessage";
+import { getFakeTransport, type ISocketLike, TCP_transport } from "./tcp_transport";
+import { decodeMessage, packTcpMessage, parseEndpointUrl } from "./tools";
 import { doTraceHelloAck } from "./utils";
 
 const doDebug = checkDebugFlag(__filename);
@@ -37,22 +37,17 @@ function createClientSocket(endpointUrl: string, timeout: number): ISocketLike {
             socket = createConnection({ host: hostname, port, timeout }, () => {
                 doDebug && debugLog(`connected to server! ${hostname}:${port} timeout:${timeout} `);
             });
-            
+
             socket.setNoDelay(false);
             socket.setKeepAlive(true, timeout >> 1);
 
-
             return socket;
         case "fake:":
             assert(ep.protocol === "fake:", " Unsupported transport protocol");
             socket = getFakeTransport();
             return socket;
-
-        case "websocket:":
-        case "http:":
-        case "https:":
         default: {
-            const msg = "[NODE-OPCUA-E05] this transport protocol is not supported :" + ep.protocol;
+            const msg = `[NODE-OPCUA-E05] this transport protocol is not supported :${ep.protocol}`;
             errorLog(msg);
             throw new Error(msg);
         }
@@ -117,6 +112,7 @@ export interface TransportSettingsOptions {
  *
  *
  */
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: typed EventEmitter events - extending parent's event map in subclass hierarchy
 export class ClientTCP_transport extends TCP_transport {
     public static defaultMaxChunk = 0; // 0 - no limits
     public static defaultMaxMessageSize = 0; // 0 - no limits
@@ -168,25 +164,24 @@ export class ClientTCP_transport extends TCP_transport {
     }
 
     public connect(endpointUrl: string, callback: ErrorCallback): void {
-
         this.endpointUrl = endpointUrl;
-        this.serverUri = "urn:" + gHostname + ":Sample";
+        this.serverUri = `urn:${gHostname}:Sample`;
         /* c8 ignore next */
-        doDebug && debugLog(chalk.cyan("ClientTCP_transport#connect(endpointUrl = " + endpointUrl + ")"));
+        doDebug && debugLog(chalk.cyan(`ClientTCP_transport#connect(endpointUrl = ${endpointUrl})`));
         let socket: ISocketLike | null = null;
         try {
-            const ep = parseEndpointUrl(endpointUrl);
+            const _ep = parseEndpointUrl(endpointUrl);
             socket = createClientSocket(endpointUrl, this.timeout);
-          
+
             socket.setTimeout(this.timeout >> 1, () => {
                 this.forceConnectionBreak();
             });
-            
         } catch (err) {
             /* c8 ignore next */
             doDebug && debugLog("CreateClientSocket has failed");
 
-            return callback(err as Error);
+            callback(err as Error);
+            return;
         }
 
         /**
@@ -226,7 +221,7 @@ export class ClientTCP_transport extends TCP_transport {
                 if (!err) {
                     /* c8 ignore next */
                     if (!this._socket) {
-                        return callback(new Error("Abandoned"));                        
+                        return callback(new Error("Abandoned"));
                     }
                     // install error handler to detect connection break
                     this._socket.on("error", _on_socket_error_after_connection);
@@ -270,30 +265,30 @@ export class ClientTCP_transport extends TCP_transport {
 
         this._install_socket(socket);
 
-        this._socket!.once("error", _on_socket_error_for_connect);
-        this._socket!.once("end", _on_socket_end_for_connect);
-        this._socket!.once("connect", _on_socket_connect);
+        this._socket?.once("error", _on_socket_error_for_connect);
+        this._socket?.once("end", _on_socket_end_for_connect);
+        this._socket?.once("connect", _on_socket_connect);
     }
 
     private _handle_ACK_response(messageChunk: Buffer, callback: ErrorCallback) {
         const _stream = new BinaryStream(messageChunk);
         const messageHeader = readMessageHeader(_stream);
-        let err;
+        let err: Error | null = null;
         /* c8 ignore next */
         if (messageHeader.isFinal !== "F") {
             err = new Error(" invalid ACK message");
             return callback(err);
         }
 
-        let responseClass;
-        let response;
+        let responseClass: typeof AcknowledgeMessage | typeof TCPErrorMessage;
+        let response: AcknowledgeMessage | TCPErrorMessage;
 
         if (messageHeader.msgType === "ERR") {
             responseClass = TCPErrorMessage;
             _stream.rewind();
             response = decodeMessage(_stream, responseClass) as TCPErrorMessage;
 
-            err = new Error("ACK: ERR received " + response.statusCode.toString() + " : " + response.reason);
+            err = new Error(`ACK: ERR received ${response.statusCode.toString()} : ${response.reason}`);
             (err as any).statusCode = response.statusCode;
             // c8 ignore next
             doTraceHelloAck && warningLog("receiving ERR instead of Ack", response.toString());
@@ -302,10 +297,10 @@ export class ClientTCP_transport extends TCP_transport {
         } else {
             responseClass = AcknowledgeMessage;
             _stream.rewind();
-            response = decodeMessage(_stream, responseClass);
+            response = decodeMessage(_stream, responseClass) as AcknowledgeMessage;
 
-            this.parameters = response as AcknowledgeMessage;
-            this.setLimits(response as AcknowledgeMessage);
+            this.parameters = response;
+            this.setLimits(response);
 
             // c8 ignore next
             doTraceHelloAck && warningLog("receiving Ack\n", response.toString());
@@ -319,7 +314,7 @@ export class ClientTCP_transport extends TCP_transport {
         doDebug && debugLog("entering _send_HELLO_request");
 
         assert(this._socket);
-        assert(isFinite(this.protocolVersion));
+        assert(Number.isFinite(this.protocolVersion));
         assert(this.endpointUrl.length > 0, " expecting a valid endpoint url");
 
         const { maxChunkCount, maxMessageSize, receiveBufferSize, sendBufferSize } = this._helloSettings;

package/source/i_hello_ack_limits.ts

@@ -1,4 +1,4 @@
-import { UInt32 } from "node-opcua-basic-types";
+import type { UInt32 } from "node-opcua-basic-types";
 
 export interface IHelloAckLimits {
     receiveBufferSize: UInt32;

package/source/index.ts

@@ -9,10 +9,10 @@
  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  * the Software, and to permit persons to whom the Software is furnished to do so,
  * subject to the following conditions:
- * 
+ *
  *   The above copyright notice and this permission notice shall be included in all
  *   copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
@@ -26,11 +26,11 @@
 export * from "./AcknowledgeMessage";
 export * from "./client_tcp_transport";
 export * from "./HelloMessage";
+export * from "./i_hello_ack_limits";
 export * from "./message_builder_base";
 export * from "./server_tcp_transport";
 export * from "./status_codes";
-export * from "./tcp_transport";
 export * from "./TCPErrorMessage";
+export * from "./tcp_transport";
 export * from "./tools";
 export * from "./utils";
-export * from "./i_hello_ack_limits";

package/source/message_builder_base.ts

@@ -1,22 +1,23 @@
 /**
  * @module node-opcua-transport
  */
-import { EventEmitter } from "events";
+import { EventEmitter } from "node:events";
 import { assert } from "node-opcua-assert";
 
 import { decodeStatusCode, decodeString, decodeUInt32 } from "node-opcua-basic-types";
 import { BinaryStream } from "node-opcua-binary-stream";
 
 import { readMessageHeader, SequenceHeader } from "node-opcua-chunkmanager";
-import { make_errorLog, make_debugLog, make_warningLog, hexDump } from "node-opcua-debug";
-import { MessageHeader, PacketAssembler, PacketInfo } from "node-opcua-packet-assembler";
-import { StatusCode } from "node-opcua-status-code";
+import { hexDump, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { type MessageHeader, PacketAssembler, type PacketInfo } from "node-opcua-packet-assembler";
+import type { StatusCode } from "node-opcua-status-code";
 import { get_clock_tick } from "node-opcua-utils";
 import { StatusCodes2 } from "./status_codes";
+
 const doPerfMonitoring = process.env.NODEOPCUADEBUG && process.env.NODEOPCUADEBUG.indexOf("PERF") >= 0;
 
 const errorLog = make_errorLog("MessageBuilder");
-const debugLog = make_debugLog("MessageBuilder");
+const _debugLog = make_debugLog("MessageBuilder");
 const warningLog = make_warningLog("MessageBuilder");
 
 export function readRawMessageHeader(data: Buffer): PacketInfo {
@@ -35,50 +36,32 @@ export interface MessageBuilderBaseOptions {
     maxChunkSize?: number;
 }
 
-export interface MessageBuilderBase {
+export interface MessageBuilderBaseEvents {
     /**
-     *
      * notify the observers that a new message is being built
-     * @event start_chunk
-     * @param info
-     * @param data
+     * @event startChunk
      */
-
-    on(eventName: "startChunk", eventHandler: (info: PacketInfo, data: Buffer) => void): this;
+    startChunk: [info: PacketInfo, data: Buffer];
     /**
      * notify the observers that new message chunk has been received
      * @event chunk
-     * @param messageChunk the raw message chunk
      */
-
-    on(eventName: "chunk", eventHandler: (chunk: Buffer) => void): this;
+    chunk: [chunk: Buffer];
     /**
      * notify the observers that an error has occurred
      * @event error
-     * @param error the error to raise
      */
-
-    on(eventName: "error", eventHandler: (err: Error, statusCode: StatusCode, requestId: number | null) => void): this;
+    error: [err: Error, statusCode: StatusCode, requestId: number | null];
     /**
      * notify the observers that a full message has been received
      * @event full_message_body
-     * @param full_message_body the full message body made of all concatenated chunks.
      */
-    on(eventName: "full_message_body", eventHandler: (fullMessageBody: Buffer) => void): this;
-
+    full_message_body: [fullMessageBody: Buffer];
     /**
-     *
-     * @param eventName "abandon"
-     * @param info
-     * @param data
+     * notify the observers that a request has been abandoned
+     * @event abandon
      */
-    on(eventName: "abandon", eventHandler: (requestId: number) => void): this;
-
-    emit(eventName: "startChunk", info: PacketInfo, data: Buffer): boolean;
-    emit(eventName: "chunk", chunk: Buffer): boolean;
-    emit(eventName: "error", err: Error, statusCode: StatusCode, requestId: number | null): boolean;
-    emit(eventName: "full_message_body", fullMessageBody: Buffer): boolean;
-    emit(eventName: "abandon", requestId: number): boolean;
+    abandon: [requestId: number];
 }
 /**
  *
@@ -158,7 +141,7 @@ export class MessageBuilderBase extends EventEmitter {
 
         this.#_packetAssembler.on("error", (err) => {
             warningLog("packet assembler ", err.message);
-            return this._report_error(StatusCodes2.BadTcpMessageTooLarge, "packet assembler: " + err.message);
+            this._report_error(StatusCodes2.BadTcpMessageTooLarge, `packet assembler: ${err.message}`);
         });
 
         this.#_securityDefeated = false;
@@ -185,7 +168,7 @@ export class MessageBuilderBase extends EventEmitter {
         }
     }
 
-    protected _decodeMessageBody(fullMessageBody: Buffer): boolean {
+    protected _decodeMessageBody(_fullMessageBody: Buffer): boolean {
         return true;
     }
 
@@ -202,11 +185,11 @@ export class MessageBuilderBase extends EventEmitter {
             }
             return true;
         } catch (err) {
-            return this._report_error(StatusCodes2.BadTcpInternalError, "_read_headers error " + (err as Error).message);
+            return this._report_error(StatusCodes2.BadTcpInternalError, `_read_headers error ${err instanceof Error ? err.message : String(err)}`);
         }
     }
 
-    protected _report_abandon(channelId: number, tokenId: number, sequenceHeader: SequenceHeader): false {
+    protected _report_abandon(_channelId: number, _tokenId: number, sequenceHeader: SequenceHeader): false {
         // the server has not been able to send a complete message and has abandoned the request
         // the connection can probably continue
         this.#_hasReceivedError = false; ///
@@ -251,7 +234,10 @@ export class MessageBuilderBase extends EventEmitter {
         this.totalMessageSize += chunk.length;
 
         if (this.totalMessageSize > this.maxMessageSize) {
-            return this._report_error(StatusCodes2.BadTcpMessageTooLarge, `max message size exceeded: ${this.maxMessageSize} : total message size ${this.totalMessageSize}`);
+            return this._report_error(
+                StatusCodes2.BadTcpMessageTooLarge,
+                `max message size exceeded: ${this.maxMessageSize} : total message size ${this.totalMessageSize}`
+            );
         }
 
         const binaryStream = new BinaryStream(chunk);
@@ -263,11 +249,12 @@ export class MessageBuilderBase extends EventEmitter {
         assert(binaryStream.length >= 12);
 
         // verify message chunk length
-        if (this.messageHeader!.length !== chunk.length) {
+        if (this.messageHeader?.length !== chunk.length) {
             // tslint:disable:max-line-length
             return this._report_error(
                 StatusCodes2.BadTcpInternalError,
-                `Invalid messageChunk size: the provided chunk is ${chunk.length} bytes long but header specifies ${this.messageHeader!.length
+                `Invalid messageChunk size: the provided chunk is ${chunk.length} bytes long but header specifies ${
+                    this.messageHeader?.length
                 }`
             );
         }
@@ -282,7 +269,7 @@ export class MessageBuilderBase extends EventEmitter {
         this.#offsetBodyStart = offsetBodyStart;
 
         // add message body to a queue
-        // We use subarray here to avoid copy. 
+        // We use subarray here to avoid copy.
         // This assumes PacketAssembler manages the buffer lifecycle appropriately.
         const sharedBuffer = chunk.subarray(this.#offsetBodyStart, offsetBodyEnd);
         this.#blocks.push(sharedBuffer);
@@ -329,7 +316,7 @@ export class MessageBuilderBase extends EventEmitter {
                 const stream = new BinaryStream(chunk);
                 readMessageHeader(stream);
                 assert(stream.length === 8);
-                // instead of 
+                // instead of
                 //   const securityHeader = new SymmetricAlgorithmSecurityHeader();
                 //   securityHeader.decode(stream);
 
@@ -341,11 +328,12 @@ export class MessageBuilderBase extends EventEmitter {
 
                 return this._report_abandon(channelId, tokenId, sequenceHeader);
             } catch (err) {
+                const errMessage = err instanceof Error ? err.message : String(err);
                 warningLog(hexDump(chunk));
-                warningLog("Cannot interpret message chunk: ", (err as Error).message);
+                warningLog("Cannot interpret message chunk: ", errMessage);
                 return this._report_error(
                     StatusCodes2.BadTcpInternalError,
-                    "Error decoding message header " + (err as Error).message
+                    `Error decoding message header ${errMessage}`
                 );
             }
         } else if (messageHeader.isFinal === "C") {

package/source/server_tcp_transport.ts

@@ -3,24 +3,22 @@
  */
 // tslint:disable:class-name
 // system
-import { types } from "util";
+
 import chalk from "chalk";
 import { assert } from "node-opcua-assert";
-
-// opcua requires
-import { checkDebugFlag, hexDump, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { BinaryStream } from "node-opcua-binary-stream";
 import { verify_message_chunk } from "node-opcua-chunkmanager";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-import { ErrorCallback } from "node-opcua-status-code";
+// opcua requires
+import { checkDebugFlag, hexDump, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import { type ErrorCallback, type StatusCode, StatusCodes } from "node-opcua-status-code";
 
 // this package requires
 import { AcknowledgeMessage } from "./AcknowledgeMessage";
 import { HelloMessage } from "./HelloMessage";
-import { ISocketLike, TCP_transport } from "./tcp_transport";
+import type { IHelloAckLimits } from "./i_hello_ack_limits";
+import { type ISocketLike, TCP_transport } from "./tcp_transport";
 import { decodeMessage, packTcpMessage } from "./tools";
 import { doTraceHelloAck } from "./utils";
-import { IHelloAckLimits } from "./i_hello_ack_limits";
 
 const debugLog = make_debugLog("TRANSPORT");
 const errorLog = make_errorLog("TRANSPORT");
@@ -65,8 +63,6 @@ const defaultTransportParameters = {
     maxMaxChunkCount: 9000
 };
 
-
-
 export function adjustLimitsWithParameters(helloMessage: IHelloAckLimits, params: ITransportParameters): IHelloAckLimits {
     const defaultReceiveBufferSize = 64 * 1024;
     const defaultSendBufferSize = 64 * 1024;
@@ -104,7 +100,6 @@ export function adjustLimitsWithParameters(helloMessage: IHelloAckLimits, params
     };
 }
 
-
 const defaultAdjustLimits = (hello: IHelloAckLimits) => adjustLimitsWithParameters(hello, defaultTransportParameters);
 interface ServerTCP_transportOptions {
     adjustLimits?: (hello: IHelloAckLimits) => IHelloAckLimits;
@@ -134,8 +129,8 @@ export class ServerTCP_transport extends TCP_transport {
 
     public toString() {
         let str = super.toString();
-        str += "helloReceived...... = " + this._helloReceived + "\n";
-        str += "aborted............ = " + this._aborted + "\n";
+        str += `helloReceived...... = ${this._helloReceived}\n`;
+        str += `aborted............ = ${this._aborted}\n`;
         return str;
     }
 
@@ -170,7 +165,7 @@ export class ServerTCP_transport extends TCP_transport {
      */
     public init(socket: ISocketLike, callback: ErrorCallback): void {
         // c8 ignore next
-        debugLog && debugLog(chalk.cyan("init socket"));
+        debugLog?.(chalk.cyan("init socket"));
 
         assert(!this._socket, "init already called!");
         this._install_socket(socket);
@@ -186,12 +181,13 @@ export class ServerTCP_transport extends TCP_transport {
         if (this._aborted) {
             errorLog("Internal Er!ror: _abortWithError already called! Should not happen here");
             // already called
-            return callback(new Error(statusCode.name));
+            callback(new Error(statusCode.name));
+            return;
         }
         this._aborted = 1;
 
         this._socket?.setTimeout(0);
-        const err = new Error(extraErrorDescription + " StatusCode = " + statusCode.name);
+        const err = new Error(`${extraErrorDescription} StatusCode = ${statusCode.name}`);
         this._theCloseError = err;
         setTimeout(() => {
             // send the error message and close the connection
@@ -235,8 +231,8 @@ export class ServerTCP_transport extends TCP_transport {
         /* c8 ignore next*/
         if (doDebug) {
             verify_message_chunk(messageChunk);
-            debugLog("server send: " + chalk.yellow("ACK"));
-            debugLog("server send: " + hexDump(messageChunk));
+            debugLog(`server send: ${chalk.yellow("ACK")}`);
+            debugLog(`server send: ${hexDump(messageChunk)}`);
             debugLog("acknowledgeMessage=", acknowledgeMessage);
         }
 
@@ -252,8 +248,13 @@ export class ServerTCP_transport extends TCP_transport {
             if (err) {
                 callback(err);
             } else {
+                // c8 ignore next
+                if (!data) {
+                    callback(new Error("No data received"));
+                    return;
+                }
                 // pass to next stage handle the HEL message
-                this._on_HEL_message(data!, callback);
+                this._on_HEL_message(data, callback);
             }
         });
     }
@@ -268,14 +269,18 @@ export class ServerTCP_transport extends TCP_transport {
 
         /* c8 ignore next*/
         if (doDebug) {
-            debugLog("SERVER received " + chalk.yellow(msgType));
-            debugLog("SERVER received " + hexDump(data));
+            debugLog(`SERVER received ${chalk.yellow(msgType)}`);
+            debugLog(`SERVER received ${hexDump(data)}`);
         }
 
         if (msgType === "HEL") {
             try {
                 assert(data.length >= 24);
-                const helloMessage = decodeMessage(stream, HelloMessage) as HelloMessage;
+                const decoded = decodeMessage(stream, HelloMessage);
+                if (!(decoded instanceof HelloMessage)) {
+                    throw new Error("expecting a HelloMessage");
+                }
+                const helloMessage = decoded;
 
                 // OPCUA Spec 1.03 part 6 - page 41
                 // The Server shall always accept versions greater than what it supports.
@@ -292,11 +297,12 @@ export class ServerTCP_transport extends TCP_transport {
                 if (helloMessage.protocolVersion === 0xdeadbeef || helloMessage.protocolVersion < this.protocolVersion) {
                     // Note: 0xDEADBEEF is our special version number to simulate BadProtocolVersionUnsupported in tests
                     // invalid protocol version requested by client
-                    return this._abortWithError(
+                    this._abortWithError(
                         StatusCodes.BadProtocolVersionUnsupported,
-                        "Protocol Version Error" + this.protocolVersion,
+                        `Protocol Version Error${this.protocolVersion}`,
                         callback
                     );
+                    return;
                 }
 
                 // OPCUA Spec 1.04 part 6 - page 45
@@ -305,11 +311,12 @@ export class ServerTCP_transport extends TCP_transport {
                 // pieces (called ‘MessageChunks’) that are smaller than the buffer size allowed by the
                 // TransportProtocol. UASC requires a TransportProtocol buffer size that is at least 8 192 bytes
                 if (helloMessage.receiveBufferSize < minimumBufferSize || helloMessage.sendBufferSize < minimumBufferSize) {
-                    return this._abortWithError(
+                    this._abortWithError(
                         StatusCodes.BadConnectionRejected,
-                        "Buffer size too small (should be at least " + minimumBufferSize,
+                        `Buffer size too small (should be at least ${minimumBufferSize}`,
                         callback
                     );
+                    return;
                 }
                 // the helloMessage shall only be received once.
                 this._helloReceived = true;
@@ -317,16 +324,13 @@ export class ServerTCP_transport extends TCP_transport {
                 callback(); // no Error
             } catch (err) {
                 // connection rejected because of malformed message
-                return this._abortWithError(
-                    StatusCodes.BadConnectionRejected,
-                    types.isNativeError(err) ? err.message : "",
-                    callback
-                );
+                this._abortWithError(StatusCodes.BadConnectionRejected, err instanceof Error ? err.message : "", callback);
+                return;
             }
         } else {
             // invalid packet , expecting HEL
             /* c8 ignore next*/
-            doDebug && debugLog(chalk.red("BadCommunicationError ") + "Expecting 'HEL' message to initiate communication");
+            doDebug && debugLog(`${chalk.red("BadCommunicationError ")}Expecting 'HEL' message to initiate communication`);
             this._abortWithError(StatusCodes.BadCommunicationError, "Expecting 'HEL' message to initiate communication", callback);
         }
     }