bdy 1.11.0-dev → 1.12.0-dev

package/distTs/src/tunnel/ssh/client.js

@@ -7,8 +7,14 @@ const ssh2_1 = require("ssh2");
 const events_1 = __importDefault(require("events"));
 const logger_1 = __importDefault(require("../../logger"));
 const texts_1 = require("../../texts");
-const utils_1 = require("../../utils");
+const tunnel_1 = require("../../types/tunnel");
 class SshClient extends events_1.default {
+    ip;
+    port;
+    username;
+    password;
+    keepalive;
+    client;
     constructor(ip, port, username, password) {
         super();
         this.ip = ip;
@@ -24,12 +30,16 @@ class SshClient extends events_1.default {
             this.client = new ssh2_1.Client();
             this.client.setNoDelay();
             this.client.on('ready', () => {
-                this.client.removeAllListeners();
-                this.client.on('error', () => { });
+                if (this.client) {
+                    this.client.removeAllListeners();
+                    this.client.on('error', () => { });
+                }
                 resolve();
             });
             this.client.once('error', (err) => {
-                this.client.removeAllListeners();
+                if (this.client) {
+                    this.client.removeAllListeners();
+                }
                 reject(err);
             });
             try {
@@ -112,29 +122,29 @@ class SshClient extends events_1.default {
             stream.emit('error', err);
             return;
         }
-        if (type === utils_1.SOCKET_TYPE_TLS) {
+        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.TLS) {
             logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('TLS'));
-            triggerStream(utils_1.SSH_CLIENT_EVENT_STREAM_TLS, ip);
+            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_TLS, ip);
             return;
         }
-        if (type === utils_1.SOCKET_TYPE_HTTP1) {
+        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.HTTP1) {
             logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('HTTP1'));
-            triggerStream(utils_1.SSH_CLIENT_EVENT_STREAM_HTTP1, ip);
+            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_HTTP1, ip);
             return;
         }
-        if (type === utils_1.SOCKET_TYPE_HTTP2) {
+        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.HTTP2) {
             logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('HTTP2'));
-            triggerStream(utils_1.SSH_CLIENT_EVENT_STREAM_HTTP2, ip);
+            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_HTTP2, ip);
             return;
         }
-        if (type === utils_1.SOCKET_TYPE_TCP) {
+        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.TCP) {
             logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('TCP'));
-            triggerStream(utils_1.SSH_CLIENT_EVENT_STREAM_TCP, ip);
+            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_TCP, ip);
             return;
         }
-        if (type === utils_1.SOCKET_TYPE_SSH) {
+        if (type === tunnel_1.TUNNEL_SOCKET_TYPE.SSH) {
             logger_1.default.debug((0, texts_1.LOG_DETECTED_STREAM)('SSH'));
-            triggerStream(utils_1.SSH_CLIENT_EVENT_STREAM_SSH, ip);
+            triggerStream(tunnel_1.TUNNEL_SSH_EVENT.STREAM_SSH, ip);
             return;
         }
         logger_1.default.debug(texts_1.LOG_WRONG_STREAM);
@@ -142,16 +152,18 @@ class SshClient extends events_1.default {
     }
     forwardIn(port) {
         return new Promise((resolve, reject) => {
-            this.client.on('tcp connection', async (info, accept) => {
-                logger_1.default.debug(texts_1.LOG_SSH_CONNECTION);
-                return this.processStream(accept(), info);
-            });
-            this.client.forwardIn('0.0.0.0', port, (err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(err);
-            });
+            if (this.client) {
+                this.client.on('tcp connection', async (info, accept) => {
+                    logger_1.default.debug(texts_1.LOG_SSH_CONNECTION);
+                    return this.processStream(accept(), info);
+                });
+                this.client.forwardIn('0.0.0.0', port, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(err);
+                });
+            }
         });
     }
     closeKeepAlive() {
@@ -164,16 +176,18 @@ class SshClient extends events_1.default {
         this.open()
             .then(() => {
             logger_1.default.debug(`SSH client opened`);
-            this.emit(utils_1.SSH_CLIENT_EVENT_CONNECTED);
-            this.client.on('close', () => {
-                logger_1.default.debug(`SSH client closed`);
-                if (this.keepalive)
-                    this.openKeepAlive();
-            });
+            this.emit(tunnel_1.TUNNEL_SSH_EVENT.CONNECTED);
+            if (this.client) {
+                this.client.on('close', () => {
+                    logger_1.default.debug(`SSH client closed`);
+                    if (this.keepalive)
+                        this.openKeepAlive();
+                });
+            }
         })
             .catch(() => {
             logger_1.default.debug(`SSH client closed`);
-            this.emit(utils_1.SSH_CLIENT_EVENT_DISCONNECTED);
+            this.emit(tunnel_1.TUNNEL_SSH_EVENT.DISCONNECTED);
             setTimeout(() => {
                 if (this.keepalive)
                     this.openKeepAlive();

package/distTs/src/tunnel/tcp.js

@@ -7,8 +7,13 @@ const net_1 = require("net");
 const uuid_1 = require("uuid");
 const events_1 = __importDefault(require("events"));
 const utils_1 = require("../utils");
-const utils_2 = require("../utils");
+const tunnel_1 = require("../types/tunnel");
 class TunnelTcp extends events_1.default {
+    id;
+    host;
+    port;
+    stream;
+    socket;
     constructor(host, port, stream) {
         super();
         this.id = (0, uuid_1.v4)();
@@ -19,39 +24,47 @@ class TunnelTcp extends events_1.default {
     }
     end() {
         try {
-            this.stream.unpipe();
-            this.socket.unpipe();
+            if (this.stream)
+                this.stream.unpipe();
+            if (this.socket)
+                this.socket.unpipe();
         }
         catch {
             // do nothing
         }
-        try {
-            this.stream.removeAllListeners();
-            this.stream.on('error', () => { });
-            this.stream.end();
-        }
-        catch {
-            // do nothing
+        if (this.stream) {
+            try {
+                this.stream.removeAllListeners();
+                this.stream.on('error', () => { });
+                this.stream.end();
+            }
+            catch {
+                // do nothing
+            }
         }
         const s1 = this.stream;
-        try {
-            this.socket.removeAllListeners();
-            this.socket.once('error', () => { });
-            this.socket.end();
-        }
-        catch {
-            // do nothing
+        if (this.socket) {
+            try {
+                this.socket.removeAllListeners();
+                this.socket.once('error', () => { });
+                this.socket.end();
+            }
+            catch {
+                // do nothing
+            }
         }
         const s2 = this.socket;
         setTimeout(() => {
             try {
-                s1.destroy();
+                if (s1)
+                    s1.destroy();
             }
             catch {
                 // do nothing
             }
             try {
-                s2.destroy();
+                if (s2)
+                    s2.destroy();
             }
             catch {
                 // do nothing
@@ -61,33 +74,39 @@ class TunnelTcp extends events_1.default {
         this.stream = null;
         this.host = null;
         this.port = null;
-        this.emit(utils_2.TCP_EVENT_CLOSED);
+        this.emit(tunnel_1.TUNNEL_EVENT_TCP.CLOSED);
     }
     pipe() {
-        this.socket.on('error', () => {
-            this.end();
-        });
-        this.socket.on('close', () => {
-            this.end();
-        });
-        this.stream.on('error', () => {
-            this.end();
-        });
-        this.stream.on('close', () => {
-            this.end();
-        });
-        try {
-            this.socket.connect({
-                noDelay: true,
-                keepAlive: true,
-                host: (0, utils_1.getRealTargetHost)(this.host),
-                port: this.port,
-            }, () => {
-                this.socket.pipe(this.stream).pipe(this.socket);
+        if (this.stream) {
+            this.stream.on('error', () => {
+                this.end();
+            });
+            this.stream.on('close', () => {
+                this.end();
             });
         }
-        catch {
-            this.end();
+        if (this.socket) {
+            this.socket.on('error', () => {
+                this.end();
+            });
+            this.socket.on('close', () => {
+                this.end();
+            });
+            try {
+                this.socket.connect({
+                    noDelay: true,
+                    keepAlive: true,
+                    host: (0, utils_1.getRealTargetHost)(this.host),
+                    port: this.port || 0,
+                }, () => {
+                    if (this.socket && this.stream) {
+                        this.socket.pipe(this.stream).pipe(this.socket);
+                    }
+                });
+            }
+            catch {
+                this.end();
+            }
         }
     }
 }