proxy_chain_rb 0.1.0

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/handler_forward.js

@@ -0,0 +1,173 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _http = require('http');
+
+var _http2 = _interopRequireDefault(_http);
+
+var _tools = require('./tools');
+
+var _handler_base = require('./handler_base');
+
+var _handler_base2 = _interopRequireDefault(_handler_base);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+/**
+ * Represents a proxied request to a HTTP server, either direct or via another upstream proxy.
+ */
+var HandlerForward = function (_HandlerBase) {
+    _inherits(HandlerForward, _HandlerBase);
+
+    function HandlerForward(options) {
+        _classCallCheck(this, HandlerForward);
+
+        var _this = _possibleConstructorReturn(this, (HandlerForward.__proto__ || Object.getPrototypeOf(HandlerForward)).call(this, options));
+
+        _this.bindHandlersToThis(['onTrgResponse', 'onTrgError']);
+        return _this;
+    }
+
+    _createClass(HandlerForward, [{
+        key: 'run',
+        value: function run() {
+            var reqOpts = this.trgParsed;
+            reqOpts.method = this.srcRequest.method;
+            reqOpts.headers = {};
+
+            // setup outbound proxy request HTTP headers
+            // TODO: var hasXForwardedFor = false;
+            // var hasVia = false;
+            // var via = '1.1 ' + hostname + ' (proxy/' + version + ')';
+
+            for (var i = 0; i < this.srcRequest.rawHeaders.length; i += 2) {
+                var headerName = this.srcRequest.rawHeaders[i];
+                var headerValue = this.srcRequest.rawHeaders[i + 1];
+
+                if (headerName === 'Connection' && headerValue === 'keep-alive') {
+                    // Keep the "Connection: keep-alive" header, to reduce the chance that the server
+                    // will detect we're not a browser and also to improve performance
+                } else if ((0, _tools.isHopByHopHeader)(headerName)) {
+                    continue;
+                } else if ((0, _tools.isInvalidHeader)(headerName, headerValue)) {
+                    continue;
+                }
+
+                /*
+                 if (!hasXForwardedFor && 'x-forwarded-for' === keyLower) {
+                    // append to existing "X-Forwarded-For" header
+                    // http://en.wikipedia.org/wiki/X-Forwarded-For
+                    hasXForwardedFor = true;
+                    value += ', ' + socket.remoteAddress;
+                    debug.proxyRequest('appending to existing "%s" header: "%s"', key, value);
+                }
+                 if (!hasVia && 'via' === keyLower) {
+                    // append to existing "Via" header
+                    hasVia = true;
+                    value += ', ' + via;
+                    debug.proxyRequest('appending to existing "%s" header: "%s"', key, value);
+                }
+                */
+
+                (0, _tools.addHeader)(reqOpts.headers, headerName, headerValue);
+            }
+
+            /*
+            // add "X-Forwarded-For" header if it's still not here by now
+            // http://en.wikipedia.org/wiki/X-Forwarded-For
+            if (!hasXForwardedFor) {
+                headers['X-Forwarded-For'] = socket.remoteAddress;
+                debug.proxyRequest('adding new "X-Forwarded-For" header: "%s"', headers['X-Forwarded-For']);
+            }
+             // add "Via" header if still not set by now
+            if (!hasVia) {
+                headers.Via = via;
+                debug.proxyRequest('adding new "Via" header: "%s"', headers.Via);
+            }
+             // custom `http.Agent` support, set `server.agent`
+            var agent = server.agent;
+            if (null != agent) {
+                debug.proxyRequest('setting custom `http.Agent` option for proxy request: %s', agent);
+                parsed.agent = agent;
+                agent = null;
+            }
+             */
+
+            // If desired, send the request via proxy
+            if (this.upstreamProxyUrlParsed) {
+                reqOpts.host = this.upstreamProxyUrlParsed.hostname;
+                reqOpts.hostname = reqOpts.host;
+                reqOpts.port = this.upstreamProxyUrlParsed.port;
+
+                // HTTP requests to proxy contain the full URL in path, for example:
+                // "GET http://www.example.com HTTP/1.1\r\n"
+                // So we need to replicate it here
+                reqOpts.path = this.srcRequest.url;
+
+                (0, _tools.maybeAddProxyAuthorizationHeader)(this.upstreamProxyUrlParsed, reqOpts.headers);
+
+                this.log('Connecting to upstream proxy ' + reqOpts.host + ':' + reqOpts.port);
+            } else {
+                this.log('Connecting to target ' + reqOpts.host);
+            }
+
+            // console.dir(requestOptions);
+
+            this.trgRequest = _http2.default.request(reqOpts);
+            this.trgRequest.on('response', this.onTrgResponse);
+            this.trgRequest.on('error', this.onTrgError);
+            this.trgRequest.on('socket', this.onTrgSocket);
+
+            // this.srcRequest.pipe(tee('to trg')).pipe(this.trgRequest);
+            this.srcRequest.pipe(this.trgRequest);
+        }
+    }, {
+        key: 'onTrgResponse',
+        value: function onTrgResponse(response) {
+            if (this.isClosed) return;
+            this.log('Received response from target (' + response.statusCode + ')');
+            // console.dir(response);
+
+            if (this.checkUpstreamProxy407(response)) return;
+
+            this.srcGotResponse = true;
+
+            // Prepare response headers
+            var headers = {};
+            for (var i = 0; i < response.rawHeaders.length; i += 2) {
+                var name = response.rawHeaders[i];
+                var value = response.rawHeaders[i + 1];
+
+                if ((0, _tools.isHopByHopHeader)(name)) continue;
+                if ((0, _tools.isInvalidHeader)(name, value)) continue;
+
+                (0, _tools.addHeader)(headers, name, value);
+            }
+
+            this.srcResponse.writeHead(response.statusCode, headers);
+            response.pipe(this.srcResponse);
+        }
+    }, {
+        key: 'onTrgError',
+        value: function onTrgError(err) {
+            if (this.isClosed) return;
+            this.log('Target socket failed: ' + (err.stack || err));
+            this.fail(err);
+        }
+    }]);
+
+    return HandlerForward;
+}(_handler_base2.default);
+
+exports.default = HandlerForward;

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/handler_tunnel_chain.js

@@ -0,0 +1,132 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _http = require('http');
+
+var _http2 = _interopRequireDefault(_http);
+
+var _handler_base = require('./handler_base');
+
+var _handler_base2 = _interopRequireDefault(_handler_base);
+
+var _tools = require('./tools');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+// import { tee } from './tools';
+
+/* globals Buffer */
+
+/**
+ * Represents a connection from source client to an external proxy using HTTP CONNECT tunnel.
+ */
+var HandlerTunnelChain = function (_HandlerBase) {
+    _inherits(HandlerTunnelChain, _HandlerBase);
+
+    function HandlerTunnelChain(options) {
+        _classCallCheck(this, HandlerTunnelChain);
+
+        var _this = _possibleConstructorReturn(this, (HandlerTunnelChain.__proto__ || Object.getPrototypeOf(HandlerTunnelChain)).call(this, options));
+
+        if (!_this.upstreamProxyUrlParsed) throw new Error('The "upstreamProxyUrlParsed" option is required');
+
+        _this.bindHandlersToThis(['onTrgRequestConnect', 'onTrgRequestAbort', 'onTrgRequestError']);
+        return _this;
+    }
+
+    _createClass(HandlerTunnelChain, [{
+        key: 'run',
+        value: function run() {
+            this.log('Connecting to upstream proxy...');
+
+            var targetHost = this.trgParsed.hostname + ':' + this.trgParsed.port;
+
+            var options = {
+                method: 'CONNECT',
+                hostname: this.upstreamProxyUrlParsed.hostname,
+                port: this.upstreamProxyUrlParsed.port,
+                path: targetHost,
+                headers: {
+                    Host: targetHost
+                }
+            };
+
+            (0, _tools.maybeAddProxyAuthorizationHeader)(this.upstreamProxyUrlParsed, options.headers);
+
+            this.trgRequest = _http2.default.request(options);
+
+            this.trgRequest.once('connect', this.onTrgRequestConnect);
+            this.trgRequest.once('abort', this.onTrgRequestAbort);
+            this.trgRequest.once('error', this.onTrgRequestError);
+            this.trgRequest.on('socket', this.onTrgSocket);
+
+            // Send the data
+            this.trgRequest.end();
+        }
+    }, {
+        key: 'onTrgRequestConnect',
+        value: function onTrgRequestConnect(response, socket, head) {
+            if (this.isClosed) return;
+            this.log('Connected to upstream proxy');
+
+            if (this.checkUpstreamProxy407(response)) return;
+
+            this.srcGotResponse = true;
+            this.srcResponse.removeListener('finish', this.onSrcResponseFinish);
+            this.srcResponse.writeHead(200, 'Connection established');
+
+            // HACK: force a flush of the HTTP header. This is to ensure 'head' is empty to avoid
+            // assert at https://github.com/request/tunnel-agent/blob/master/index.js#L160
+            // See also https://github.com/nodejs/node/blob/master/lib/_http_outgoing.js#L217
+            this.srcResponse._send('');
+
+            // relinquish control of the `socket` from the ServerResponse instance
+            this.srcResponse.detachSocket(this.srcSocket);
+
+            // nullify the ServerResponse object, so that it can be cleaned
+            // up before this socket proxying is completed
+            this.srcResponse = null;
+
+            // Forward pre-parsed parts of the first packets (if any)
+            if (head && head.length > 0) {
+                this.srcSocket.write(head);
+            }
+            if (this.srcHead && this.srcHead.length > 0) {
+                this.trgSocket.write(this.srcHead);
+            }
+
+            // Setup bi-directional tunnel
+            this.trgSocket.pipe(this.srcSocket);
+            this.srcSocket.pipe(this.trgSocket);
+        }
+    }, {
+        key: 'onTrgRequestAbort',
+        value: function onTrgRequestAbort() {
+            if (this.isClosed) return;
+            this.log('Target aborted');
+            this.close();
+        }
+    }, {
+        key: 'onTrgRequestError',
+        value: function onTrgRequestError(err) {
+            if (this.isClosed) return;
+            this.log('Target request failed: ' + (err.stack || err));
+            this.fail(err);
+        }
+    }]);
+
+    return HandlerTunnelChain;
+}(_handler_base2.default);
+
+exports.default = HandlerTunnelChain;

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/handler_tunnel_direct.js

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _net = require('net');
+
+var _net2 = _interopRequireDefault(_net);
+
+var _handler_base = require('./handler_base');
+
+var _handler_base2 = _interopRequireDefault(_handler_base);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+/**
+ * Represents a proxied connection from source to the target HTTPS server.
+ */
+var HandlerTunnelDirect = function (_HandlerBase) {
+    _inherits(HandlerTunnelDirect, _HandlerBase);
+
+    function HandlerTunnelDirect(options) {
+        _classCallCheck(this, HandlerTunnelDirect);
+
+        var _this = _possibleConstructorReturn(this, (HandlerTunnelDirect.__proto__ || Object.getPrototypeOf(HandlerTunnelDirect)).call(this, options));
+
+        _this.bindHandlersToThis(['onTrgSocketConnect']);
+        return _this;
+    }
+
+    _createClass(HandlerTunnelDirect, [{
+        key: 'run',
+        value: function run() {
+            this.log('Connecting to target ' + this.trgParsed.hostname + ':' + this.trgParsed.port);
+
+            var socket = _net2.default.createConnection(this.trgParsed.port, this.trgParsed.hostname);
+            socket.once('connect', this.onTrgSocketConnect);
+
+            this.onTrgSocket(socket);
+        }
+    }, {
+        key: 'onTrgSocketConnect',
+        value: function onTrgSocketConnect(response, socket, head) {
+            if (this.isClosed) return;
+            this.log('Connected');
+
+            this.srcGotResponse = true;
+
+            this.srcResponse.removeListener('finish', this.onSrcResponseFinish);
+            this.srcResponse.writeHead(200, 'Connection established');
+
+            // HACK: force a flush of the HTTP header. This is to ensure 'head' is empty to avoid
+            // assert at https://github.com/request/tunnel-agent/blob/master/index.js#L160
+            // See also https://github.com/nodejs/node/blob/master/lib/_http_outgoing.js#L217
+            this.srcResponse._send('');
+
+            // Relinquish control of the socket from the ServerResponse instance
+            this.srcResponse.detachSocket(this.srcSocket);
+
+            // ServerResponse is no longer needed
+            this.srcResponse = null;
+
+            // Forward pre-parsed parts of the first packets (if any)
+            if (head && head.length > 0) {
+                this.srcSocket.write(head);
+            }
+            if (this.srcHead && this.srcHead.length > 0) {
+                this.trgSocket.write(this.srcHead);
+            }
+
+            // Setup bi-directional tunnel
+            this.trgSocket.pipe(this.srcSocket);
+            this.srcSocket.pipe(this.trgSocket);
+        }
+    }]);
+
+    return HandlerTunnelDirect;
+}(_handler_base2.default);
+
+exports.default = HandlerTunnelDirect;

data/lib/proxy_chain_rb/node_js/proxy-chain-server/node_modules/proxy-chain/build/handler_tunnel_tcp_chain.js

@@ -0,0 +1,271 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _http = require('http');
+
+var _http2 = _interopRequireDefault(_http);
+
+var _tools = require('./tools');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/* globals Buffer */
+
+// TODO: please rename this class to something else than "Handler", it makes it look like the class inherits from HandlerBase, which it doesn't
+
+/**
+ * Represents a connection from source client to an external proxy using HTTP CONNECT tunnel, allows TCP connection.
+ */
+var HandlerTunnelTcpChain = function () {
+    function HandlerTunnelTcpChain(_ref) {
+        var srcSocket = _ref.srcSocket,
+            trgParsed = _ref.trgParsed,
+            upstreamProxyUrlParsed = _ref.upstreamProxyUrlParsed,
+            log = _ref.log;
+
+        _classCallCheck(this, HandlerTunnelTcpChain);
+
+        this.log = log;
+
+        // Bind all event handlers to this instance
+        this.bindHandlersToThis(['onSrcSocketClose', 'onSrcSocketEnd', 'onSrcSocketError', 'onTrgSocket', 'onTrgSocketClose', 'onTrgSocketEnd', 'onTrgSocketError', 'onTrgRequestConnect', 'onTrgRequestAbort', 'onTrgRequestError']);
+
+        if (!trgParsed.hostname) throw new Error('The "trgParsed.hostname" option is required');
+        if (!trgParsed.port) throw new Error('The "trgParsed.port" option is required');
+
+        this.trgRequest = null;
+        this.trgSocket = null;
+        this.trgParsed = trgParsed;
+        this.trgParsed.port = this.trgParsed.port || DEFAULT_TARGET_PORT;
+
+        this.srcSocket = srcSocket;
+        this.srcSocket.once('close', this.onSrcSocketClose);
+        this.srcSocket.once('end', this.onSrcSocketEnd);
+        this.srcSocket.once('error', this.onSrcSocketError);
+
+        this.upstreamProxyUrlParsed = upstreamProxyUrlParsed;
+
+        this.isClosed = false;
+    }
+
+    _createClass(HandlerTunnelTcpChain, [{
+        key: 'bindHandlersToThis',
+        value: function bindHandlersToThis(handlerNames) {
+            var _this = this;
+
+            handlerNames.forEach(function (evt) {
+                _this[evt] = _this[evt].bind(_this);
+            });
+        }
+    }, {
+        key: 'run',
+        value: function run() {
+            this.log('Connecting to upstream proxy...');
+
+            var options = {
+                method: 'CONNECT',
+                hostname: this.upstreamProxyUrlParsed.hostname,
+                port: this.upstreamProxyUrlParsed.port,
+                path: this.trgParsed.hostname + ':' + this.trgParsed.port,
+                headers: {}
+            };
+
+            (0, _tools.maybeAddProxyAuthorizationHeader)(this.upstreamProxyUrlParsed, options.headers);
+
+            this.trgRequest = _http2.default.request(options);
+
+            this.trgRequest.once('connect', this.onTrgRequestConnect);
+            this.trgRequest.once('abort', this.onTrgRequestAbort);
+            this.trgRequest.once('error', this.onTrgRequestError);
+            this.trgRequest.on('socket', this.onTrgSocket);
+
+            // Send the data
+            this.trgRequest.end();
+        }
+
+        // If the client closes the connection prematurely,
+        // then immediately destroy the upstream socket, there's nothing we can do with it
+
+    }, {
+        key: 'onSrcSocketClose',
+        value: function onSrcSocketClose() {
+            if (this.isClosed) return;
+            this.log('Source socket closed');
+            this.close();
+        }
+    }, {
+        key: 'onSrcSocketEnd',
+        value: function onSrcSocketEnd() {
+            if (this.isClosed) return;
+            this.log('Source socket ended');
+            this.close();
+        }
+    }, {
+        key: 'onSrcSocketError',
+        value: function onSrcSocketError(err) {
+            if (this.isClosed) return;
+            this.log('Source socket failed: ' + (err.stack || err));
+            this.close();
+        }
+    }, {
+        key: 'onTrgSocket',
+        value: function onTrgSocket(socket) {
+            if (this.isClosed) return;
+
+            this.log('Target socket assigned');
+
+            this.trgSocket = socket;
+
+            socket.once('close', this.onTrgSocketClose);
+            socket.once('end', this.onTrgSocketEnd);
+            socket.once('error', this.onTrgSocketError);
+        }
+
+        // Once target socket closes, we need to give time
+        // to source socket to receive pending data, so we only call end()
+
+    }, {
+        key: 'onTrgSocketClose',
+        value: function onTrgSocketClose() {
+            var _this2 = this;
+
+            if (this.isClosed) return;
+            this.log('Target socket closed');
+            setTimeout(function () {
+                if (_this2.srcSocket) _this2.srcSocket.end();
+            }, 100);
+        }
+    }, {
+        key: 'onTrgSocketEnd',
+        value: function onTrgSocketEnd() {
+            var _this3 = this;
+
+            if (this.isClosed) return;
+            this.log('Target socket ended');
+            setTimeout(function () {
+                if (_this3.srcSocket) _this3.srcSocket.end();
+            }, 100);
+        }
+    }, {
+        key: 'onTrgSocketError',
+        value: function onTrgSocketError(err) {
+            if (this.isClosed) return;
+            this.log('Target socket failed: ' + (err.stack || err));
+            this.fail(err);
+        }
+    }, {
+        key: 'onTrgRequestConnect',
+        value: function onTrgRequestConnect(response) {
+            if (this.isClosed) return;
+            this.log('Connected to upstream proxy');
+
+            if (this.checkUpstreamProxy407(response)) return;
+
+            // Setup bi-directional tunnel
+            this.trgSocket.pipe(this.srcSocket);
+            this.srcSocket.pipe(this.trgSocket);
+
+            this.srcSocket.resume();
+        }
+    }, {
+        key: 'onTrgRequestAbort',
+        value: function onTrgRequestAbort() {
+            if (this.isClosed) return;
+            this.log('Target aborted');
+            this.close();
+        }
+    }, {
+        key: 'onTrgRequestError',
+        value: function onTrgRequestError(err) {
+            if (this.isClosed) return;
+            this.log('Target request failed: ' + (err.stack || err));
+            this.fail(err);
+        }
+
+        /**
+         * Checks whether response from upstream proxy is 407 Proxy Authentication Required
+         * and if so, responds 502 Bad Gateway to client.
+         * @param response
+         * @return {boolean}
+         */
+
+    }, {
+        key: 'checkUpstreamProxy407',
+        value: function checkUpstreamProxy407(response) {
+            if (this.upstreamProxyUrlParsed && response.statusCode === 407) {
+                this.fail('Invalid credentials provided for the upstream proxy.', 502);
+                return true;
+            }
+            return false;
+        }
+    }, {
+        key: 'fail',
+        value: function fail(err, statusCode) {
+            if (this.srcGotResponse) {
+                this.log('Source already received a response, just destroying the socket...');
+                this.close();
+            } else if (statusCode) {
+                // Manual error
+                this.log(err + ', responding with custom status code ' + statusCode + ' to client');
+            } else if (err.code === 'ENOTFOUND' && !this.upstreamProxyUrlParsed) {
+                this.log('Target server not found, sending 404 to client');
+            } else if (err.code === 'ENOTFOUND' && this.upstreamProxyUrlParsed) {
+                this.log('Upstream proxy not found, sending 502 to client');
+            } else if (err.code === 'ECONNREFUSED') {
+                this.log('Upstream proxy refused connection, sending 502 to client');
+            } else if (err.code === 'ETIMEDOUT') {
+                this.log('Connection timed out, sending 502 to client');
+            } else if (err.code === 'ECONNRESET') {
+                this.log('Connection lost, sending 502 to client');
+            } else if (err.code === 'EPIPE') {
+                this.log('Socket closed before write, sending 502 to client');
+            } else {
+                this.log('Unknown error, sending 500 to client');
+            }
+        }
+        /**
+         * Detaches all listeners and destroys all sockets.
+         */
+
+    }, {
+        key: 'close',
+        value: function close() {
+            if (!this.isClosed) {
+                this.log('Closing handler');
+
+                if (this.srcRequest) {
+                    this.srcRequest.destroy();
+                    this.srcRequest = null;
+                }
+
+                if (this.srcSocket) {
+                    this.srcSocket.destroy();
+                    this.srcSocket = null;
+                }
+
+                if (this.trgRequest) {
+                    this.trgRequest.abort();
+                    this.trgRequest = null;
+                }
+
+                if (this.trgSocket) {
+                    this.trgSocket.destroy();
+                    this.trgSocket = null;
+                }
+
+                this.isClosed = true;
+            }
+        }
+    }]);
+
+    return HandlerTunnelTcpChain;
+}();
+
+exports.default = HandlerTunnelTcpChain;