mirror of
https://github.com/bitinflow/localtunnel.git
synced 2026-03-18 16:05:54 +00:00
HTTPS support, Promise API, modern ES syntax
* Add support for tunneling a local HTTPS server. * Return a Promise from localtunnel.
This commit is contained in:
Gert Hengeveld
committed by
Roman Shtylman
Roman Shtylman
parent
d7330a7121
commit
2a74d6be9f
@@ -1,133 +1,152 @@
|
||||
var EventEmitter = require('events').EventEmitter;
|
||||
var debug = require('debug')('localtunnel:client');
|
||||
var net = require('net');
|
||||
const { EventEmitter } = require('events');
|
||||
const debug = require('debug')('localtunnel:client');
|
||||
const fs = require('fs');
|
||||
const net = require('net');
|
||||
const tls = require('tls');
|
||||
|
||||
var HeaderHostTransformer = require('./HeaderHostTransformer');
|
||||
const HeaderHostTransformer = require('./HeaderHostTransformer');
|
||||
|
||||
// manages groups of tunnels
|
||||
var TunnelCluster = function(opt) {
|
||||
if (!(this instanceof TunnelCluster)) {
|
||||
return new TunnelCluster(opt);
|
||||
}
|
||||
module.exports = class TunnelCluster extends EventEmitter {
|
||||
constructor(opts = {}) {
|
||||
super(opts);
|
||||
this.opts = opts;
|
||||
}
|
||||
|
||||
var self = this;
|
||||
self._opt = opt;
|
||||
open() {
|
||||
const opt = this.opts;
|
||||
|
||||
EventEmitter.call(self);
|
||||
};
|
||||
// Prefer IP if returned by the server
|
||||
const remoteHostOrIp = opt.remote_ip || opt.remote_host;
|
||||
const remotePort = opt.remote_port;
|
||||
const localHost = opt.local_host || 'localhost';
|
||||
const localPort = opt.local_port;
|
||||
const localProtocol = opt.local_https ? 'https' : 'http';
|
||||
const allowInvalidCert = opt.allow_invalid_cert;
|
||||
|
||||
TunnelCluster.prototype.__proto__ = EventEmitter.prototype;
|
||||
|
||||
// establish a new tunnel
|
||||
TunnelCluster.prototype.open = function() {
|
||||
var self = this;
|
||||
|
||||
var opt = self._opt || {};
|
||||
|
||||
var remote_host = opt.remote_host;
|
||||
var remote_port = opt.remote_port;
|
||||
|
||||
var local_host = opt.local_host || 'localhost';
|
||||
var local_port = opt.local_port;
|
||||
|
||||
debug('establishing tunnel %s:%s <> %s:%s', local_host, local_port, remote_host, remote_port);
|
||||
debug(
|
||||
'establishing tunnel %s://%s:%s <> %s:%s',
|
||||
localProtocol,
|
||||
localHost,
|
||||
localPort,
|
||||
remoteHostOrIp,
|
||||
remotePort
|
||||
);
|
||||
|
||||
// connection to localtunnel server
|
||||
var remote = net.connect({
|
||||
host: remote_host,
|
||||
port: remote_port
|
||||
const remote = net.connect({
|
||||
host: remoteHostOrIp,
|
||||
port: remotePort,
|
||||
});
|
||||
|
||||
remote.setKeepAlive(true);
|
||||
|
||||
remote.on('error', function(err) {
|
||||
// emit connection refused errors immediately, because they
|
||||
// indicate that the tunnel can't be established.
|
||||
if (err.code === 'ECONNREFUSED') {
|
||||
self.emit('error', new Error('connection refused: ' + remote_host + ':' + remote_port + ' (check your firewall settings)'));
|
||||
}
|
||||
remote.on('error', err => {
|
||||
debug('got remote connection error', err.message);
|
||||
|
||||
remote.end();
|
||||
// emit connection refused errors immediately, because they
|
||||
// indicate that the tunnel can't be established.
|
||||
if (err.code === 'ECONNREFUSED') {
|
||||
this.emit(
|
||||
'error',
|
||||
new Error(
|
||||
`connection refused: ${remoteHostOrIp}:${remotePort} (check your firewall settings)`
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
remote.end();
|
||||
});
|
||||
|
||||
function conn_local() {
|
||||
if (remote.destroyed) {
|
||||
debug('remote destroyed');
|
||||
self.emit('dead');
|
||||
return;
|
||||
const connLocal = () => {
|
||||
if (remote.destroyed) {
|
||||
debug('remote destroyed');
|
||||
this.emit('dead');
|
||||
return;
|
||||
}
|
||||
|
||||
debug('connecting locally to %s://%s:%d', localProtocol, localHost, localPort);
|
||||
remote.pause();
|
||||
|
||||
if (allowInvalidCert) {
|
||||
debug('allowing invalid certificates');
|
||||
}
|
||||
|
||||
const getLocalCertOpts = () =>
|
||||
allowInvalidCert
|
||||
? { rejectUnauthorized: false }
|
||||
: {
|
||||
cert: fs.readFileSync(opt.local_cert),
|
||||
key: fs.readFileSync(opt.local_key),
|
||||
ca: opt.local_ca ? [fs.readFileSync(opt.local_ca)] : undefined,
|
||||
};
|
||||
|
||||
// connection to local http server
|
||||
const local = opt.local_https
|
||||
? tls.connect({ host: localHost, port: localPort, ...getLocalCertOpts() })
|
||||
: net.connect({ host: localHost, port: localPort });
|
||||
|
||||
const remoteClose = () => {
|
||||
debug('remote close');
|
||||
this.emit('dead');
|
||||
local.end();
|
||||
};
|
||||
|
||||
remote.once('close', remoteClose);
|
||||
|
||||
// TODO some languages have single threaded servers which makes opening up
|
||||
// multiple local connections impossible. We need a smarter way to scale
|
||||
// and adjust for such instances to avoid beating on the door of the server
|
||||
local.once('error', err => {
|
||||
debug('local error %s', err.message);
|
||||
local.end();
|
||||
|
||||
remote.removeListener('close', remoteClose);
|
||||
|
||||
if (err.code !== 'ECONNREFUSED') {
|
||||
return remote.end();
|
||||
}
|
||||
|
||||
debug('connecting locally to %s:%d', local_host, local_port);
|
||||
remote.pause();
|
||||
// retrying connection to local server
|
||||
setTimeout(connLocal, 1000);
|
||||
});
|
||||
|
||||
// connection to local http server
|
||||
var local = net.connect({
|
||||
host: local_host,
|
||||
port: local_port
|
||||
});
|
||||
local.once('connect', () => {
|
||||
debug('connected locally');
|
||||
remote.resume();
|
||||
|
||||
function remote_close() {
|
||||
debug('remote close');
|
||||
self.emit('dead');
|
||||
local.end();
|
||||
};
|
||||
let stream = remote;
|
||||
|
||||
remote.once('close', remote_close);
|
||||
|
||||
// TODO some languages have single threaded servers which makes opening up
|
||||
// multiple local connections impossible. We need a smarter way to scale
|
||||
// and adjust for such instances to avoid beating on the door of the server
|
||||
local.once('error', function(err) {
|
||||
debug('local error %s', err.message);
|
||||
local.end();
|
||||
|
||||
remote.removeListener('close', remote_close);
|
||||
|
||||
if (err.code !== 'ECONNREFUSED') {
|
||||
return remote.end();
|
||||
}
|
||||
|
||||
// retrying connection to local server
|
||||
setTimeout(conn_local, 1000);
|
||||
});
|
||||
|
||||
local.once('connect', function() {
|
||||
debug('connected locally');
|
||||
remote.resume();
|
||||
|
||||
var stream = remote;
|
||||
|
||||
// if user requested specific local host
|
||||
// then we use host header transform to replace the host header
|
||||
if (opt.local_host) {
|
||||
debug('transform Host header to %s', opt.local_host);
|
||||
stream = remote.pipe(HeaderHostTransformer({ host: opt.local_host }));
|
||||
}
|
||||
|
||||
stream.pipe(local).pipe(remote);
|
||||
|
||||
// when local closes, also get a new remote
|
||||
local.once('close', function(had_error) {
|
||||
debug('local connection closed [%s]', had_error);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
remote.on('data', function(data) {
|
||||
const match = data.toString().match(/^(\w+) (\S+)/);
|
||||
if (match) {
|
||||
self.emit('request', {
|
||||
method: match[1],
|
||||
path: match[2],
|
||||
});
|
||||
// if user requested specific local host
|
||||
// then we use host header transform to replace the host header
|
||||
if (opt.local_host) {
|
||||
debug('transform Host header to %s', opt.local_host);
|
||||
stream = remote.pipe(new HeaderHostTransformer({ host: opt.local_host }));
|
||||
}
|
||||
|
||||
stream.pipe(local).pipe(remote);
|
||||
|
||||
// when local closes, also get a new remote
|
||||
local.once('close', hadError => {
|
||||
debug('local connection closed [%s]', hadError);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
remote.on('data', data => {
|
||||
const match = data.toString().match(/^(\w+) (\S+)/);
|
||||
if (match) {
|
||||
this.emit('request', {
|
||||
method: match[1],
|
||||
path: match[2],
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// tunnel is considered open when remote connects
|
||||
remote.once('connect', function() {
|
||||
self.emit('open', remote);
|
||||
conn_local();
|
||||
remote.once('connect', () => {
|
||||
this.emit('open', remote);
|
||||
connLocal();
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = TunnelCluster;
|
||||
|
||||
Reference in New Issue
Block a user