node-opcua-transport 2.99.0 → 2.102.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-transport",
-    "version": "2.99.0",
+    "version": "2.102.0",
     "description": "pure nodejs OPCUA SDK - module transport",
     "main": "./dist/source/index.js",
     "types": "./dist/source/index.d.ts",
@@ -26,6 +26,7 @@
         "node-opcua-utils": "2.98.1"
     },
     "devDependencies": {
+        "node-opcua-leak-detector": "2.99.0",
         "should": "^13.2.3",
         "sinon": "^15.0.3"
     },
@@ -44,7 +45,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "90ce9f5b44d74198d84a384de622dfa94fd05c0c",
+    "gitHead": "07dcdd8e8c7f2b55544c6e23023093e35674829c",
     "files": [
         "dist",
         "source"

package/source/client_tcp_transport.ts

@@ -2,7 +2,8 @@
  * @module node-opcua-transport
  */
 import * as os from "os";
-import { createConnection, Socket } from "net";
+import { createConnection } from "net";
+import { types } from "util";
 import * as chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
@@ -11,7 +12,7 @@ import { readMessageHeader } from "node-opcua-chunkmanager";
 import { ErrorCallback } from "node-opcua-status-code";
 
 import * as debug from "node-opcua-debug";
-import { getFakeTransport, TCP_transport } from "./tcp_transport";
+import { getFakeTransport, ISocketLike, TCP_transport } from "./tcp_transport";
 import { decodeMessage, packTcpMessage, parseEndpointUrl } from "./tools";
 
 import { AcknowledgeMessage } from "./AcknowledgeMessage";
@@ -25,31 +26,27 @@ const warningLog = debug.make_warningLog(__filename);
 const errorLog = debug.make_errorLog(__filename);
 const gHostname = os.hostname();
 
-function createClientSocket(endpointUrl: string): Socket {
+function createClientSocket(endpointUrl: string, timeout: number): ISocketLike {
     // create a socket based on Url
     const ep = parseEndpointUrl(endpointUrl);
     const port = parseInt(ep.port!, 10);
     const hostname = ep.hostname!;
-    let socket: Socket;
+
+    let socket: ISocketLike;
     switch (ep.protocol) {
         case "opc.tcp:":
-            socket = createConnection({ host: hostname, port });
-
-            socket.setKeepAlive(true);
-
-            // Setting true for noDelay will immediately fire off data each time socket.write() is called.
-            socket.setNoDelay(true);
-
+            socket = createConnection({ host: hostname, port, timeout }, () => {
+                doDebug && debugLog(`connected to server! ${hostname}:${port} timeout:${timeout} `);
+            });
             return socket;
         case "fake:":
-            socket = getFakeTransport();
             assert(ep.protocol === "fake:", " Unsupported transport protocol");
-            process.nextTick(() => socket.emit("connect"));
+            socket = getFakeTransport();
             return socket;
 
         case "websocket:":
         case "http:":
-        case "https:FF":
+        case "https:":
         default: {
             const msg = "[NODE-OPCUA-E05] this transport protocol is not supported :" + ep.protocol;
             errorLog(msg);
@@ -59,19 +56,16 @@ function createClientSocket(endpointUrl: string): Socket {
 }
 export interface ClientTCP_transport {
     on(eventName: "chunk", eventHandler: (messageChunk: Buffer) => void): this;
-    on(eventName: "socket_closed", eventHandler: (err: Error | null) => void): this;
     on(eventName: "close", eventHandler: (err: Error | null) => void): this;
     on(eventName: "connection_break", eventHandler: () => void): this;
     on(eventName: "connect", eventHandler: () => void): this;
 
     once(eventName: "chunk", eventHandler: (messageChunk: Buffer) => void): this;
-    once(eventName: "socket_closed", eventHandler: (err: Error | null) => void): this;
     once(eventName: "close", eventHandler: (err: Error | null) => void): this;
     once(eventName: "connection_break", eventHandler: () => void): this;
     once(eventName: "connect", eventHandler: () => void): this;
 
     emit(eventName: "chunk", messageChunk: Buffer): boolean;
-    emit(eventName: "socket_closed", err?: Error | null): boolean;
     emit(eventName: "close", err?: Error | null): boolean;
     emit(eventName: "connection_break"): boolean;
     emit(eventName: "connect"): boolean;
@@ -99,7 +93,7 @@ export interface TransportSettingsOptions {
  *
  *    transport.timeout = 10000;
  *
- *    transport.connect(function(err)) {
+ *    transport.connect(function (err)) {
  *         if (err) {
  *            // cannot connect
  *         } else {
@@ -109,16 +103,16 @@ export interface TransportSettingsOptions {
  *    });
  *    ....
  *
- *    transport.write(message_chunk,'F');
+ *    transport.write(message_chunk, 'F');
  *
  *    ....
  *
- *    transport.on("chunk",function(message_chunk) {
+ *    transport.on("chunk", function (message_chunk) {
  *        // do something with chunk from server...
  *    });
  *
  *
- *    ```
+ * ```
  *
  *
  */
@@ -133,7 +127,6 @@ export class ClientTCP_transport extends TCP_transport {
     public numberOfRetry: number;
     public parameters?: AcknowledgeMessage;
 
-    private connected: boolean;
     private _counter: number;
     private _helloSettings: {
         maxChunkCount: number;
@@ -143,7 +136,6 @@ export class ClientTCP_transport extends TCP_transport {
     };
     constructor(transportSettings?: TransportSettingsOptions) {
         super();
-        this.connected = false;
         this.endpointUrl = "";
         this.serverUri = "";
         this._counter = 0;
@@ -169,9 +161,8 @@ export class ClientTCP_transport extends TCP_transport {
 
     public dispose(): void {
         /* istanbul ignore next */
-        if (doDebug) {
-            debugLog(" ClientTCP_transport disposed");
-        }
+        doDebug && debugLog(" ClientTCP_transport disposed");
+
         super.dispose();
     }
 
@@ -185,24 +176,25 @@ export class ClientTCP_transport extends TCP_transport {
 
         this.serverUri = "urn:" + gHostname + ":Sample";
         /* istanbul ignore next */
-        if (doDebug) {
-            debugLog(chalk.cyan("ClientTCP_transport#connect(endpointUrl = " + endpointUrl + ")"));
-        }
+        doDebug && debugLog(chalk.cyan("ClientTCP_transport#connect(endpointUrl = " + endpointUrl + ")"));
+
+        let socket: ISocketLike | null = null;
         try {
-            this._socket = createClientSocket(endpointUrl);
+            socket = createClientSocket(endpointUrl, this.timeout);
         } catch (err) {
             /* istanbul ignore next */
-            if (doDebug) {
-                debugLog("CreateClientSocket has failed");
-            }
+            doDebug && debugLog("CreateClientSocket has failed");
+
             return callback(err as Error);
         }
 
+        /**
+         *
+         */
         const _on_socket_error_after_connection = (err: Error) => {
             /* istanbul ignore next */
-            if (doDebug) {
-                debugLog(" _on_socket_error_after_connection ClientTCP_transport Socket Error", err.message);
-            }
+            doDebug && debugLog(" _on_socket_error_after_connection ClientTCP_transport Socket Error", err.message);
+
             // EPIPE : EPIPE (Broken pipe): A write on a pipe, socket, or FIFO for which there is no process to read the
             // data. Commonly encountered at the net and http layers, indicative that the remote side of the stream
             // being written to has been closed.
@@ -210,7 +202,11 @@ export class ClientTCP_transport extends TCP_transport {
             // ECONNRESET (Connection reset by peer): A connection was forcibly closed by a peer. This normally results
             // from a loss of the connection on the remote socket due to a timeout or reboot. Commonly encountered
             // via the http and net module
-            if (err.message.match(/ECONNRESET|EPIPE/)) {
+
+            //  socket termination could happen:
+            //   * when the socket times out (lost of connection, network outage, etc...)
+            //   * or, when the server abruptly disconnects the socket ( in case of invalid communication for instance)
+            if (err.message.match(/ECONNRESET|EPIPE|premature socket termination/)) {
                 /**
                  * @event connection_break
                  *
@@ -221,11 +217,10 @@ export class ClientTCP_transport extends TCP_transport {
 
         const _on_socket_connect = () => {
             /* istanbul ignore next */
-            if (doDebug) {
-                debugLog("entering _on_socket_connect");
-            }
+            doDebug && debugLog("entering _on_socket_connect");
+
             _remove_connect_listeners();
-            this._perform_HEL_ACK_transaction((err?: Error) => {
+            this._perform_HEL_ACK_transaction((err) => {
                 if (!err) {
                     /* istanbul ignore next */
                     if (!this._socket) {
@@ -234,7 +229,6 @@ export class ClientTCP_transport extends TCP_transport {
                     // install error handler to detect connection break
                     this._socket.on("error", _on_socket_error_after_connection);
 
-                    this.connected = true;
                     /**
                      * notify the observers that the transport is connected (the socket is connected and the the HEL/ACK
                      * transaction has been done)
@@ -252,22 +246,16 @@ export class ClientTCP_transport extends TCP_transport {
         const _on_socket_error_for_connect = (err: Error) => {
             // this handler will catch attempt to connect to an inaccessible address.
             /* istanbul ignore next */
-            if (doDebug) {
-                debugLog(chalk.cyan("ClientTCP_transport#connect - _on_socket_error_for_connect"), err.message);
-            }
-            assert(err instanceof Error);
+            doDebug && debugLog(chalk.cyan("ClientTCP_transport#connect - _on_socket_error_for_connect"), err.message);
+            assert(types.isNativeError(err));
             _remove_connect_listeners();
             callback(err);
         };
 
-        const _on_socket_end_for_connect = (err: Error | null) => {
+        const _on_socket_end_for_connect = () => {
             /* istanbul ignore next */
-            if (doDebug) {
-                debugLog(
-                    chalk.cyan("ClientTCP_transport#connect -> _on_socket_end_for_connect Socket has been closed by server"),
-                    err
-                );
-            }
+            doDebug &&
+                debugLog(chalk.cyan("ClientTCP_transport#connect -> _on_socket_end_for_connect Socket has been closed by server"));
         };
 
         const _remove_connect_listeners = () => {
@@ -279,21 +267,11 @@ export class ClientTCP_transport extends TCP_transport {
             this._socket.removeListener("end", _on_socket_end_for_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);
+        this._install_socket(socket);
 
-        this._install_socket(this._socket);
-    }
-
-    protected on_socket_ended(err: Error | null): void {
-        debugLog("on_socket_ended", this.name, err ? err.message : "");
-        if (this.connected) {
-            super.on_socket_ended(err);
-        }
-        //  if (this._socket) {
-        //      this._socket.removeAllListeners();
-        // }
+        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) {
@@ -317,9 +295,8 @@ export class ClientTCP_transport extends TCP_transport {
             err = new Error("ACK: ERR received " + response.statusCode.toString() + " : " + response.reason);
             (err as any).statusCode = response.statusCode;
             // istanbul ignore next
-            if (doTraceHelloAck) {
-                warningLog("receiving ERR instead of Ack", response.toString());
-            }
+            doTraceHelloAck && warningLog("receiving ERR instead of Ack", response.toString());
+
             callback(err);
         } else {
             responseClass = AcknowledgeMessage;
@@ -330,9 +307,7 @@ export class ClientTCP_transport extends TCP_transport {
             this.setLimits(response as AcknowledgeMessage);
 
             // istanbul ignore next
-            if (doTraceHelloAck) {
-                warningLog("receiving Ack\n", response.toString());
-            }
+            doTraceHelloAck && warningLog("receiving Ack\n", response.toString());
 
             callback();
         }
@@ -340,9 +315,8 @@ export class ClientTCP_transport extends TCP_transport {
 
     private _send_HELLO_request() {
         /* istanbul ignore next */
-        if (doDebug) {
-            debugLog("entering _send_HELLO_request");
-        }
+        doDebug && debugLog("entering _send_HELLO_request");
+
         assert(this._socket);
         assert(isFinite(this.protocolVersion));
         assert(this.endpointUrl.length > 0, " expecting a valid endpoint url");
@@ -360,9 +334,7 @@ export class ClientTCP_transport extends TCP_transport {
             sendBufferSize
         });
         // istanbul ignore next
-        if (doTraceHelloAck) {
-            warningLog(`sending Hello\n ${helloMessage.toString()}`);
-        }
+        doTraceHelloAck && warningLog(`sending Hello\n ${helloMessage.toString()} `);
 
         const messageChunk = packTcpMessage("HEL", helloMessage);
         this._write_chunk(messageChunk);
@@ -370,9 +342,7 @@ export class ClientTCP_transport extends TCP_transport {
 
     private _on_ACK_response(externalCallback: ErrorCallback, err: Error | null, data?: Buffer) {
         /* istanbul ignore next */
-        if (doDebug) {
-            debugLog("entering _on_ACK_response");
-        }
+        doDebug && debugLog("entering _on_ACK_response");
 
         assert(typeof externalCallback === "function");
         assert(this._counter === 0, "Ack response should only be received once !");
@@ -382,7 +352,6 @@ export class ClientTCP_transport extends TCP_transport {
             externalCallback(err || new Error("no data"));
             if (this._socket) {
                 this._socket.end();
-                // Xx this._socket.removeAllListeners();
             }
         } else {
             this._handle_ACK_response(data, externalCallback);
@@ -398,14 +367,12 @@ export class ClientTCP_transport extends TCP_transport {
         assert(typeof callback === "function");
         this._counter = 0;
         /* istanbul ignore next */
-        if (doDebug) {
-            debugLog("entering _perform_HEL_ACK_transaction");
-        }
+        doDebug && debugLog("entering _perform_HEL_ACK_transaction");
+
         this._install_one_time_message_receiver((err: Error | null, data?: Buffer) => {
             /* istanbul ignore next */
-            if (doDebug) {
-                debugLog("before  _on_ACK_response ", err ? err.message : "");
-            }
+            doDebug && debugLog("before  _on_ACK_response ", err ? err.message : "");
+
             this._on_ACK_response(callback, err, data);
         });
         this._send_HELLO_request();

package/source/server_tcp_transport.ts

@@ -4,6 +4,7 @@
 // tslint:disable:class-name
 // system
 import { Socket } from "net";
+import { types } from "util";
 import * as chalk from "chalk";
 import { assert } from "node-opcua-assert";
 
@@ -17,16 +18,15 @@ import { ErrorCallback } from "node-opcua-status-code";
 // this package requires
 import { AcknowledgeMessage } from "./AcknowledgeMessage";
 import { HelloMessage } from "./HelloMessage";
-import { TCP_transport } from "./tcp_transport";
+import { ISocketLike, TCP_transport } from "./tcp_transport";
 import { decodeMessage, packTcpMessage } from "./tools";
 import { doTraceHelloAck } from "./utils";
 
 const hexDump = debug.hexDump;
-const debugLog = debug.make_debugLog(__filename);
-const errorLog = debug.make_errorLog(__filename);
-const doDebug = debug.checkDebugFlag(__filename);
-
-type CallbackFunc = (err: null | Error) => void;
+const debugLog = debug.make_debugLog("TRANSPORT");
+const errorLog = debug.make_errorLog("TRANSPORT");
+const warningLog = debug.make_warningLog("TRANSPORT");
+const doDebug = debug.checkDebugFlag("TRANSPORT");
 
 function clamp_value(value: number, minVal: number, maxVal: number): number {
     assert(minVal < maxVal);
@@ -45,12 +45,6 @@ function clamp_value(value: number, minVal: number, maxVal: number): number {
 
 const minimumBufferSize = 8192;
 
-/**
- * @class ServerTCP_transport
- * @extends TCP_transport
- * @constructor
- *
- */
 export class ServerTCP_transport extends TCP_transport {
     public static throttleTime = 1000;
 
@@ -68,6 +62,13 @@ export class ServerTCP_transport extends TCP_transport {
         this.receiveBufferSize = 4 * 1024;
     }
 
+    public toString() {
+        let str = super.toString();
+        str += "helloReceived...... = " + this._helloReceived + "\n";
+        str += "aborted............ = " + this._aborted + "\n";
+        return str;
+    }
+
     protected _write_chunk(messageChunk: Buffer): void {
         // istanbul ignore next
         if (this.sendBufferSize > 0 && messageChunk.length > this.sendBufferSize) {
@@ -78,9 +79,9 @@ export class ServerTCP_transport extends TCP_transport {
                 this.sendBufferSize
             );
         }
-
         super._write_chunk(messageChunk);
     }
+
     /**
      * Initialize the server transport.
      *
@@ -97,10 +98,11 @@ export class ServerTCP_transport extends TCP_transport {
      *
      *
      */
-    public init(socket: Socket, callback: ErrorCallback): void {
-        if (debugLog) {
-            debugLog(chalk.cyan("init socket"));
-        }
+    public init(socket: ISocketLike, callback: ErrorCallback): void {
+        assert(socket, "missing called!");
+        // istanbul ignore next
+        debugLog && debugLog(chalk.cyan("init socket"));
+
         assert(!this._socket, "init already called!");
         assert(typeof callback === "function", "expecting a valid callback ");
 
@@ -108,30 +110,28 @@ export class ServerTCP_transport extends TCP_transport {
         this._install_HEL_message_receiver(callback);
     }
 
-    public abortWithError(statusCode: StatusCode, extraErrorDescription: string, callback: ErrorCallback): void {
-        return this._abortWithError(statusCode, extraErrorDescription, callback);
-    }
-
     private _abortWithError(statusCode: StatusCode, extraErrorDescription: string, callback: ErrorCallback): void {
         // When a fatal error occurs, the Server shall send an Error Message to the Client and
         // closes the TransportConnection gracefully.
-        doDebug && debugLog(chalk.cyan("_abortWithError"));
+        doDebug && debugLog(this.name, chalk.cyan("_abortWithError", statusCode.toString(), extraErrorDescription));
 
         /* istanbul ignore next */
         if (this._aborted) {
+            errorLog("Internal Er!ror: _abortWithError already called! Should not happen here");
             // already called
             return callback(new Error(statusCode.name));
         }
         this._aborted = 1;
 
+        this._socket?.setTimeout(0);
+        const err = new Error(extraErrorDescription + " StatusCode = " + statusCode.name);
+        this._theCloseError = err;
         setTimeout(() => {
             // send the error message and close the connection
             this.sendErrorMessage(statusCode, statusCode.description);
-
-            this.disconnect(() => {
-                this._aborted = 2;
-                callback(new Error(extraErrorDescription + " StatusCode = " + statusCode.name));
-            });
+            this.prematureTerminate(err, statusCode);
+            this._emitClose(err);
+            callback(err);
         }, ServerTCP_transport.throttleTime);
     }
 
@@ -179,11 +179,12 @@ export class ServerTCP_transport extends TCP_transport {
 
         // istanbul ignore next
         if (doTraceHelloAck) {
-            console.log(`received Hello \n${helloMessage.toString()}`);
-            console.log("Client accepts only message of size => ", this.maxMessageSize);
+            warningLog(`received Hello \n${helloMessage.toString()}`);
+            warningLog("Client accepts only message of size => ", this.maxMessageSize);
         }
 
-        debugLog("Client accepts only message of size => ", this.maxMessageSize);
+        // istanbul ignore next
+        doDebug && debugLog("Client accepts only message of size => ", this.maxMessageSize);
 
         const acknowledgeMessage = new AcknowledgeMessage({
             maxChunkCount: this.maxChunkCount,
@@ -194,9 +195,7 @@ export class ServerTCP_transport extends TCP_transport {
         });
 
         // istanbul ignore next
-        if (doTraceHelloAck) {
-            console.log(`sending Ack \n${acknowledgeMessage.toString()}`);
-        }
+        doTraceHelloAck && warningLog(`sending Ack \n${acknowledgeMessage.toString()}`);
 
         const messageChunk = packTcpMessage("ACK", acknowledgeMessage);
 
@@ -213,12 +212,12 @@ export class ServerTCP_transport extends TCP_transport {
     }
 
     private _install_HEL_message_receiver(callback: ErrorCallback): void {
-        if (debugLog) {
-            debugLog(chalk.cyan("_install_HEL_message_receiver "));
-        }
+        // istanbul ignore next
+        doDebug && debugLog(chalk.cyan("_install_HEL_message_receiver "));
+
         this._install_one_time_message_receiver((err?: Error | null, data?: Buffer) => {
             if (err) {
-                this._abortWithError(StatusCodes.BadConnectionRejected, err.message, callback);
+                callback(err);
             } else {
                 // handle the HEL message
                 this._on_HEL_message(data!, callback);
@@ -227,9 +226,9 @@ export class ServerTCP_transport extends TCP_transport {
     }
 
     private _on_HEL_message(data: Buffer, callback: ErrorCallback): void {
-        if (debugLog) {
-            debugLog(chalk.cyan("_on_HEL_message"));
-        }
+        // istanbul ignore next
+        doDebug && debugLog(chalk.cyan("_on_HEL_message"));
+
         assert(!this._helloReceived);
         const stream = new BinaryStream(data);
         const msgType = data.subarray(0, 3).toString("utf-8");
@@ -244,16 +243,17 @@ export class ServerTCP_transport extends TCP_transport {
             try {
                 assert(data.length >= 24);
                 const helloMessage = decodeMessage(stream, HelloMessage) as HelloMessage;
-                assert(isFinite(this.protocolVersion));
 
                 // OPCUA Spec 1.03 part 6 - page 41
                 // The Server shall always accept versions greater than what it supports.
                 if (helloMessage.protocolVersion !== this.protocolVersion) {
-                    debugLog(
-                        `warning ! client sent helloMessage.protocolVersion = ` +
-                            ` 0x${helloMessage.protocolVersion.toString(16)} ` +
-                            `whereas server protocolVersion is 0x${this.protocolVersion.toString(16)}`
-                    );
+                    // istanbul ignore next
+                    doDebug &&
+                        debugLog(
+                            `warning ! client sent helloMessage.protocolVersion = ` +
+                                ` 0x${helloMessage.protocolVersion.toString(16)} ` +
+                                `whereas server protocolVersion is 0x${this.protocolVersion.toString(16)}`
+                        );
                 }
 
                 if (helloMessage.protocolVersion === 0xdeadbeef || helloMessage.protocolVersion < this.protocolVersion) {
@@ -283,15 +283,13 @@ export class ServerTCP_transport extends TCP_transport {
                 this._send_ACK_response(helloMessage);
             } catch (err) {
                 // connection rejected because of malformed message
-                return this._abortWithError(StatusCodes.BadConnectionRejected, err instanceof Error ? err.message : "", callback);
+                return this._abortWithError(StatusCodes.BadConnectionRejected, types.isNativeError(err) ? err.message : "", callback);
             }
             callback(); // no Error
         } else {
             // invalid packet , expecting HEL
             /* istanbul ignore next*/
-            if (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);
         }
     }