v1.8.0

Emit socket errors, so they can be handled

.npmignore

@@ -0,0 +1 @@
+support

.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+    - "0.10"

History.md

@@ -0,0 +1,36 @@
+# 1.8.0 (2015-11-04)
+
+* pass socket errors up to top level
+
+# 1.7.0 (2015-07-22)
+
+* add short arg options
+
+# 1.6.0 (2015-05-15)
+
+* keep sockets alive after connecting
+* add --open param to CLI
+
+# 1.5.0 (2014-10-25)
+
+* capture all errors on remote socket and restart the tunnel
+
+# 1.4.0 (2014-08-31)
+
+* don't emit errors for ETIMEDOUT
+
+# 1.2.0 / 2014-04-28
+
+* return `client` from `localtunnel` API instantiation
+
+# 1.1.0 / 2014-02-24
+
+* add a host header transform to change the 'Host' header in requests
+
+# 1.0.0 / 2014-02-14
+
+* default to localltunnel.me for host
+* remove exported `connect` method (just export one function that does the same thing)
+* change localtunnel signature to (port, opt, fn)
+
+# 0.2.2 / 2014-01-09

README.md

@@ -1,8 +1,8 @@
-# localtunnel #
+# localtunnel [![Build Status](https://travis-ci.org/defunctzombie/localtunnel.png?branch=master)](https://travis-ci.org/defunctzombie/localtunnel) #
 
 localtunnel exposes your localhost to the world for easy testing and sharing! No need to mess with DNS or deploy just to have others test out your changes.
 
-Great for working with browser testing tools like browserling or external api callback services like twilio which require a public url for callbacks!
+Great for working with browser testing tools like browserling or external api callback services like twilio which require a public url for callbacks.
 
 ## installation ##
 
@@ -10,9 +10,11 @@ Great for working with browser testing tools like browserling or external api ca
 npm install -g localtunnel
 ```
 
+This will install the localtunnel module globally and add the 'lt' client cli tool to your PATH.
+
 ## use ##
 
-Super East! Assuming your local server is running on port 8000, just use the ```lt``` command to start the tunnel.
+Assuming your local server is running on port 8000, just use the ```lt``` command to start the tunnel.
 
 ```
 lt --port 8000
@@ -21,3 +23,67 @@ lt --port 8000
 Thats it! It will connect to the tunnel server, setup the tunnel, and tell you what url to use for your testing. This url will remain active for the duration of your session; so feel free to share it with others for happy fun time!
 
 You can restart your local server all you want, ```lt``` is smart enough to detect this and reconnect once it is back.
+
+### arguments
+
+Below are some common arguments. See `lt --help` for additional arguments
+
+* `--subdomain` request a named subdomain on the localtunnel server (default is random characters)
+* `--local-host` proxy to a hostname other than localhost
+
+## API ##
+
+The localtunnel client is also usable through an API (for test integration, automation, etc)
+
+### localtunnel(port [,opts], fn)
+
+Creates a new localtunnel to the specified local `port`. `fn` will be called once you have been assigned a public localtunnel url. `opts` can be used to request a specific `subdomain`.
+
+```javascript
+var localtunnel = require('localtunnel');
+
+var tunnel = localtunnel(port, function(err, tunnel) {
+    if (err) ...
+
+    // the assigned public url for your tunnel
+    // i.e. https://abcdefgjhij.localtunnel.me
+    tunnel.url;
+});
+
+tunnel.on('close', function() {
+    // tunnels are closed
+});
+```
+
+### opts
+
+* `subdomain` A *string* value requesting a specific subdomain on the proxy server. **Note** You may not actually receive this name depending on availablily.
+* `local_host` Proxy to this hostname instead of `localhost`. This will also cause the `Host` header to be re-written to this value in proxied requests.
+
+### Tunnel
+
+The `tunnel` instance returned to your callback emits the following events
+
+|event|args|description|
+|----|----|----|
+|error|err|fires when an error happens on the tunnel|
+|close||fires when the tunnel has closed|
+
+The `tunnel instance has the following methods
+
+|method|args|description|
+|----|----|----|
+|close||close the tunnel|
+
+## other clients ##
+
+Clients in other languages
+
+*go* [gotunnelme](https://github.com/NoahShen/gotunnelme)
+
+## server ##
+
+See defunctzombie/localtunnel-server for details on the server that powers localtunnel.
+
+## License ##
+MIT

bin/client

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+var lt_client = require('../client');
+var open_url = require('openurl');
+
+var argv = require('yargs')
+    .usage('Usage: $0 --port [num] <options>')
+    .option('h', {
+        alias: 'host',
+        describe: 'Upstream server providing forwarding',
+        default: 'http://localtunnel.me'
+    })
+    .option('s', {
+        alias: 'subdomain',
+        describe: 'Request this subdomain'
+    })
+    .option('l', {
+        alias: 'local-host',
+        describe: 'Tunnel traffic to this host instead of localhost, override Host header to this host'
+    })
+    .options('o', {
+        alias: 'open',
+        describe: 'opens url in your browser'
+    })
+    .option('p', {
+        alias: 'port',
+        describe: 'Internal http server port',
+    })
+    .require('port')
+    .help('help', 'Show this help and exit')
+    .version(require('../package').version)
+    .argv;
+
+if (typeof argv.port !== 'number') {
+    require('yargs').showHelp();
+    console.error('port must be a number');
+    process.exit(1);
+}
+
+var opt = {
+    host: argv.host,
+    port: argv.port,
+    local_host: argv['local-host'],
+    subdomain: argv.subdomain,
+};
+
+lt_client(opt.port, opt, function(err, tunnel) {
+    if (err) {
+        throw err;
+    }
+
+    console.log('your url is: %s', tunnel.url);
+
+    if (argv.open) {
+        open_url.open(tunnel.url);
+    }
+
+    tunnel.on('error', function(err) {
+        throw err;
+    });
+});
+
+// vim: ft=javascript

bin/lt

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-require(__dirname + '/../client');

client.js

@@ -1,95 +1,24 @@
-// builtin
-var net = require('net');
-var url = require('url');
-var request = require('request');
+var EventEmitter = require('events').EventEmitter;
+var debug = require('debug')('localtunnel:client');
 
-var argv = require('optimist')
-    .usage('Usage: $0 --port [num]')
-    .demand(['port'])
-    .options('host', {
-        default: 'http://localtunnel.me',
-        describe: 'upstream server providing forwarding'
-    })
-    .describe('port', 'internal http server port')
-    .argv;
+var Tunnel = require('./lib/Tunnel');
 
-// local port
-var local_port = argv.port;
+module.exports = function localtunnel(port, opt, fn) {
+    if (typeof opt === 'function') {
+        fn = opt;
+        opt = {};
+    }
 
-// optionally override the upstream server
-var upstream = url.parse(argv.host);
+    opt = opt || {};
+    opt.port = port;
 
-// query options
-var opt = {
-    host: upstream.hostname,
-    port: upstream.port || 80,
-    path: '/',
-    json: true
-};
-
-var base_uri = 'http://' + opt.host + ':' + opt.port + opt.path;
-
-var internal;
-var upstream;
-var prev_id;
-
-(function connect_proxy() {
-    opt.uri = base_uri + ((prev_id) ? prev_id : '?new');
-
-    request(opt, function(err, res, body) {
+    var client = Tunnel(opt);
+    client.open(function(err) {
         if (err) {
-            console.error('upstream not available: %s', err.message);
-            return process.exit(-1);
+            return fn(err);
         }
 
-        // our assigned hostname and tcp port
-        var port = body.port;
-        var host = opt.host;
-
-        // store the id so we can try to get the same one
-        prev_id = body.id;
-
-        console.log('your url is: %s', body.url);
-
-        // connect to remote tcp server
-        upstream = net.createConnection(port, host);
-
-        // reconnect internal
-        connect_internal();
-
-        upstream.on('end', function() {
-            console.log('> upstream connection terminated');
-
-            // sever connection to internal server
-            // on reconnect we will re-establish
-            internal.end();
-
-            setTimeout(function() {
-                connect_proxy();
-            }, 1000);
-        });
+        fn(null, client);
     });
-})();
-
-function connect_internal() {
-
-    internal = net.createConnection(local_port);
-    internal.on('error', function(err) {
-        console.log('error connecting to local server. retrying in 1s');
-
-        setTimeout(function() {
-            connect_internal();
-        }, 1000);
-    });
-
-    internal.on('end', function() {
-        console.log('disconnected from local server. retrying in 1s');
-        setTimeout(function() {
-            connect_internal();
-        }, 1000);
-    });
-
-    upstream.pipe(internal);
-    internal.pipe(upstream);
-}
-
+    return client;
+};

lib/HeaderHostTransformer.js

@@ -0,0 +1,39 @@
+var stream = require('stream');
+var util = require('util');
+
+var Transform = stream.Transform;
+
+var HeaderHostTransformer = function(opts) {
+    if (!(this instanceof HeaderHostTransformer)) {
+        return new HeaderHostTransformer(opts);
+    }
+
+    opts = opts || {}
+    Transform.call(this, opts);
+
+    var self = this;
+    self.host = opts.host || 'localhost';
+    self.replaced = false;
+}
+util.inherits(HeaderHostTransformer, Transform);
+
+HeaderHostTransformer.prototype._transform = function (chunk, enc, cb) {
+    var self = this;
+    chunk = chunk.toString();
+
+    // after replacing the first instance of the Host header
+    // we just become a regular passthrough
+    if (!self.replaced) {
+        self.push(chunk.replace(/(\r\nHost: )\S+/, function(match, $1) {
+            self.replaced = true;
+            return $1 + self.host;
+        }));
+    }
+    else {
+        self.push(chunk);
+    }
+
+    cb();
+};
+
+module.exports = HeaderHostTransformer;

lib/Tunnel.js

@@ -0,0 +1,157 @@
+var url = require('url');
+var EventEmitter = require('events').EventEmitter;
+var request = require('request');
+var debug = require('debug')('localtunnel:client');
+
+var TunnelCluster = require('./TunnelCluster');
+
+var Tunnel = function(opt) {
+    if (!(this instanceof Tunnel)) {
+        return new Tunnel(opt);
+    }
+
+    var self = this;
+    self._closed = false;
+    self._opt = opt || {};
+
+    self._opt.host = self._opt.host || 'https://localtunnel.me';
+};
+
+Tunnel.prototype.__proto__ = EventEmitter.prototype;
+
+// initialize connection
+// callback with connection info
+Tunnel.prototype._init = function(cb) {
+    var self = this;
+    var opt = self._opt;
+
+    var params = {
+        path: '/',
+        json: true
+    };
+
+    var base_uri = opt.host + '/';
+
+    // optionally override the upstream server
+    var upstream = url.parse(opt.host);
+
+    // no subdomain at first, maybe use requested domain
+    var assigned_domain = opt.subdomain;
+
+    // where to quest
+    params.uri = base_uri + ((assigned_domain) ? assigned_domain : '?new');
+
+    (function get_url() {
+        request(params, function(err, res, body) {
+            if (err) {
+                // TODO (shtylman) don't print to stdout?
+                console.log('tunnel server offline: ' + err.message + ', retry 1s');
+                return setTimeout(get_url, 1000);
+            }
+
+            if (res.statusCode !== 200) {
+                var err = new Error((body && body.message) || 'localtunnel server returned an error, please try again');
+                return cb(err);
+            }
+
+            var port = body.port;
+            var host = upstream.hostname;
+
+            var max_conn = body.max_conn_count || 1;
+
+            cb(null, {
+                remote_host: upstream.hostname,
+                remote_port: body.port,
+                name: body.id,
+                url: body.url,
+                max_conn: max_conn
+            });
+        });
+    })();
+};
+
+Tunnel.prototype._establish = function(info) {
+    var self = this;
+    var opt = self._opt;
+    
+    // increase max event listeners so that localtunnel consumers don't get
+    // warning messages as soon as they setup even one listener. See #71
+    self.setMaxListeners(info.max_conn + (EventEmitter.defaultMaxListeners || 10));
+
+    info.local_host = opt.local_host;
+    info.local_port = opt.port;
+
+    var tunnels = self.tunnel_cluster = TunnelCluster(info);
+
+    // only emit the url the first time
+    tunnels.once('open', function() {
+        self.emit('url', info.url);
+    });
+
+    // re-emit socket error
+    tunnels.on('error', function(err) {
+        self.emit('error', err);
+    });
+
+    var tunnel_count = 0;
+
+    // track open count
+    tunnels.on('open', function(tunnel) {
+        tunnel_count++;
+        debug('tunnel open [total: %d]', tunnel_count);
+
+        var close_handler = function() {
+            tunnel.destroy();
+        };
+
+        if (self._closed) {
+            return close_handler();
+        }
+
+        self.once('close', close_handler);
+        tunnel.once('close', function() {
+            self.removeListener('close', close_handler);
+        });
+    });
+
+    // when a tunnel dies, open a new one
+    tunnels.on('dead', function(tunnel) {
+        tunnel_count--;
+        debug('tunnel dead [total: %d]', tunnel_count);
+
+        if (self._closed) {
+            return;
+        }
+
+        tunnels.open();
+    });
+
+    // establish as many tunnels as allowed
+    for (var count = 0 ; count < info.max_conn ; ++count) {
+        tunnels.open();
+    }
+};
+
+Tunnel.prototype.open = function(cb) {
+    var self = this;
+
+    self._init(function(err, info) {
+        if (err) {
+            return cb(err);
+        }
+
+        self.url = info.url;
+        self._establish(info);
+        cb();
+    });
+};
+
+// shutdown tunnels
+Tunnel.prototype.close = function() {
+    var self = this;
+
+    self._closed = true;
+    self.emit('close');
+};
+
+module.exports = Tunnel;

lib/TunnelCluster.js

@@ -0,0 +1,123 @@
+var EventEmitter = require('events').EventEmitter;
+var debug = require('debug')('localtunnel:client');
+var net = require('net');
+
+var HeaderHostTransformer = require('./HeaderHostTransformer');
+
+// manages groups of tunnels
+var TunnelCluster = function(opt) {
+    if (!(this instanceof TunnelCluster)) {
+        return new TunnelCluster(opt);
+    }
+
+    var self = this;
+    self._opt = opt;
+
+    EventEmitter.call(self);
+};
+
+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);
+
+    // connection to localtunnel server
+    var remote = net.connect({
+        host: remote_host,
+        port: remote_port
+    });
+
+    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.end();
+    });
+
+    function conn_local() {
+        if (remote.destroyed) {
+            debug('remote destroyed');
+            self.emit('dead');
+            return;
+        }
+
+        debug('connecting locally to %s:%d', local_host, local_port);
+        remote.pause();
+
+        // connection to local http server
+        var local = net.connect({
+            host: local_host,
+            port: local_port
+        });
+
+        function remote_close() {
+            debug('remote close');
+            self.emit('dead');
+            local.end();
+        };
+
+        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);
+            });
+        });
+    }
+
+    // tunnel is considered open when remote connects
+    remote.once('connect', function() {
+        self.emit('open', remote);
+        conn_local();
+    });
+};
+
+module.exports = TunnelCluster;

package.json

@@ -2,22 +2,26 @@
   "author": "Roman Shtylman <shtylman@gmail.com>",
   "name": "localtunnel",
   "description": "expose localhost to the world",
-  "version": "0.0.1",
+  "version": "1.8.0",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git://github.com/shtylman/localtunnel.git"
   },
   "dependencies": {
-    "request": "2.11.4",
-    "book": "1.2.0",
-    "optimist": "0.3.4"
+    "request": "2.65.0",
+    "yargs": "3.29.0",
+    "debug": "2.2.0",
+    "openurl": "1.1.0"
   },
-  "devDependencies": {},
-  "optionalDependencies": {},
-  "engines": {
-    "node": "*"
+  "devDependencies": {
+    "mocha": "~1.17.0"
+  },
+  "scripts": {
+    "test": "mocha --ui qunit --reporter list --timeout 10000 -- test/index.js"
   },
   "bin": {
-    "lt": "./bin/lt"
-  }
-}
+    "lt": "./bin/client"
+  },
+  "main": "./client.js"
+}

server.js

@@ -1,343 +0,0 @@
-
-// builtin
-var http = require('http');
-var net = require('net');
-var url = require('url');
-var FreeList = require('freelist').FreeList;
-
-var argv = require('optimist')
-    .usage('Usage: $0 --port [num]')
-    .options('port', {
-        default: '80',
-        describe: 'listen on this port for outside requests'
-    })
-    .argv;
-
-if (argv.help) {
-    require('optimist').showHelp();
-    process.exit();
-}
-
-// here be dragons
-var HTTPParser = process.binding('http_parser').HTTPParser;
-var ServerResponse = http.ServerResponse;
-var IncomingMessage = http.IncomingMessage;
-
-var log = require('book');
-
-var chars = 'abcdefghiklmnopqrstuvwxyz';
-function rand_id() {
-    var randomstring = '';
-    for (var i=0; i<4; ++i) {
-        var rnum = Math.floor(Math.random() * chars.length);
-        randomstring += chars[rnum];
-    }
-
-    return randomstring;
-}
-
-var server = http.createServer();
-
-// id -> client http server
-var clients = {};
-
-// id -> list of sockets waiting for a valid response
-var wait_list = {};
-
-var parsers = http.parsers;
-
-// data going back to a client (the last client that made a request)
-function socketOnData(d, start, end) {
-
-    var socket = this;
-    var req = this._httpMessage;
-
-    var current = clients[socket.subdomain].current;
-
-    if (!current) {
-        log.error('no current for http response from backend');
-        return;
-    }
-
-    // send the goodies
-    current.write(d.slice(start, end));
-
-    // invoke parsing so we know when all the goodies have been sent
-    var parser = current.out_parser;
-    parser.socket = socket;
-
-    var ret = parser.execute(d, start, end - start);
-    if (ret instanceof Error) {
-        debug('parse error');
-        freeParser(parser, req);
-        socket.destroy(ret);
-    }
-}
-
-function freeParser(parser, req) {
-    if (parser) {
-        parser._headers = [];
-        parser.onIncoming = null;
-        if (parser.socket) {
-            parser.socket.onend = null;
-            parser.socket.ondata = null;
-            parser.socket.parser = null;
-        }
-        parser.socket = null;
-        parser.incoming = null;
-        parsers.free(parser);
-        parser = null;
-    }
-    if (req) {
-        req.parser = null;
-    }
-}
-
-// single http connection
-// gets a single http response back
-server.on('connection', function(socket) {
-
-    var self = this;
-
-    var for_client = false;
-    var client_id;
-
-    var request;
-
-    var parser = parsers.alloc();
-    parser.socket = socket;
-    parser.reinitialize(HTTPParser.REQUEST);
-
-    // a full request is complete
-    // we wait for the response from the server
-    parser.onIncoming = function(req, shouldKeepAlive) {
-
-        log.trace('request', req.url);
-        request = req;
-
-        for_client = false;
-
-        var hostname = req.headers.host;
-
-        if (!hostname) {
-            log.trace('no hostname: %j', req.headers);
-            // normal processing if not proxy
-            var res = new ServerResponse(req);
-
-            // TODO(shtylman) skip favicon for now, it caused problems
-            if (req.url === '/favicon.ico') {
-                return;
-            }
-
-            res.assignSocket(parser.socket);
-            self.emit('request', req, res);
-            return;
-        }
-
-        var match = hostname.match(/^([a-z]{4})[.].*/);
-
-        if (!match) {
-            // normal processing if not proxy
-            var res = new ServerResponse(req);
-
-            // TODO(shtylman) skip favicon for now, it caused problems
-            if (req.url === '/favicon.ico') {
-                return;
-            }
-
-            res.assignSocket(parser.socket);
-            self.emit('request', req, res);
-            return;
-        }
-
-        client_id = match[1];
-        for_client = true;
-
-        var out_parser = parsers.alloc();
-        out_parser.reinitialize(HTTPParser.RESPONSE);
-        socket.out_parser = out_parser;
-
-        // we have a response
-        out_parser.onIncoming = function(res) {
-            res.on('end', function() {
-                log.trace('done with response for: %s', req.url);
-
-                // done with the parser
-                parsers.free(out_parser);
-
-                var next = wait_list[client_id].shift();
-
-                clients[client_id].current = next;
-
-                if (!next) {
-                    return;
-                }
-
-                // write original bytes that we held cause client was busy
-                clients[client_id].write(next.queue);
-                next.resume();
-            });
-        };
-    };
-
-    // process new data on the client socket
-    // we may need to forward this it the backend
-    socket.ondata = function(d, start, end) {
-        var ret = parser.execute(d, start, end - start);
-
-        // invalid request from the user
-        if (ret instanceof Error) {
-            debug('parse error');
-            socket.destroy(ret);
-            return;
-        }
-
-        // only write data if previous request to this client is done?
-        log.trace('%s %s', parser.incoming && parser.incoming.upgrade, for_client);
-
-        // what if the subdomains are treated differently
-        // as individual channels to the backend if available?
-        // how can I do that?
-
-        if (parser.incoming && parser.incoming.upgrade) {
-            // websocket shit
-        }
-
-        // wtf do you do with upgraded connections?
-
-        // forward the data to the backend
-        if (for_client) {
-            var client = clients[client_id];
-
-            // requesting a subdomain that doesn't exist
-            if (!client) {
-                return;
-            }
-
-            // if the client is already processing something
-            // then new connections need to go into pause mode
-            // and when they are revived, then they can send data along
-            if (client.current && client.current !== socket) {
-                log.trace('pausing', request.url);
-                // prevent new data from gathering for this connection
-                // we are waiting for a response to a previous request
-                socket.pause();
-
-                var copy = Buffer(end - start);
-                d.copy(copy, 0, start, end);
-                socket.queue = copy;
-
-                wait_list[client_id].push(socket);
-
-                return;
-            }
-
-            // this socket needs to receive responses
-            client.current = socket;
-
-            // send through tcp tunnel
-            client.write(d.slice(start, end));
-        }
-    };
-
-    socket.onend = function() {
-        var ret = parser.finish();
-
-        if (ret instanceof Error) {
-            log.trace('parse error');
-            socket.destroy(ret);
-            return;
-        }
-
-        socket.end();
-    };
-
-    socket.on('close', function() {
-        parsers.free(parser);
-    });
-});
-
-server.on('request', function(req, res) {
-
-    // ignore favicon
-    if (req.url === '/favicon.ico') {
-        res.writeHead(404);
-        return res.end();
-    }
-
-    var parsed = url.parse(req.url, true);
-
-    // redirect main page to github reference
-    if (req.url === '/' && !parsed.query.new) {
-        res.writeHead(301, { Location: 'http://shtylman.github.com/localtunnel/' });
-        res.end();
-    }
-
-    var match = req.url.match(/\/([a-z]{4})?/);
-
-    // user can request a particular set of characters
-    // will be given if not already taken
-    // this is useful when the main server is restarted
-    // users can keep testing with their expected ids
-    var requested_id;
-    if (match && match[1]) {
-        requested_id = match[1];
-    }
-
-    var id = requested_id || rand_id();
-    if (wait_list[id]) {
-        // new id
-        id = rand_id();
-    }
-
-    // generate new shit for client
-    if (wait_list[id]) {
-        wait_list[id].forEach(function(waiting) {
-            waiting.end();
-        });
-    }
-
-    var client_server = net.createServer();
-    client_server.listen(function() {
-        var port = client_server.address().port;
-        log.info('tcp server listening on port: %d', port);
-
-        var url = 'http://' + id + '.' + req.headers.host;
-
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ url: url, id: id, port: port }));
-    });
-
-    // user has 5 seconds to connect before their slot is given up
-    var conn_timeout = setTimeout(function() {
-        client_server.close();
-    }, 5000);
-
-    client_server.on('connection', function(socket) {
-
-        // who the info should route back to
-        socket.subdomain = id;
-
-        // multiplexes socket data out to clients
-        socket.ondata = socketOnData;
-
-        clearTimeout(conn_timeout);
-
-        log.trace('new connection for id: %s', id);
-        clients[id] = socket;
-        wait_list[id] = [];
-
-        socket.on('end', function() {
-            delete clients[id];
-        });
-    });
-
-    client_server.on('err', function(err) {
-        log.error(err);
-    });
-});
-
-server.listen(argv.port, function() {
-    log.info('server listening on port: %d', server.address().port);
-});
-

test/index.js

@@ -0,0 +1,188 @@
+var http = require('http');
+var https = require('https');
+var url = require('url');
+var assert = require('assert');
+
+var localtunnel = require('../');
+
+test('setup local http server', function(done) {
+    var server = http.createServer();
+    server.on('request', function(req, res) {
+        res.write(req.headers.host);
+        res.end();
+    });
+    server.listen(function() {
+        var port = server.address().port;
+
+        test._fake_port = port;
+        console.log('local http on:', port);
+        done();
+    });
+});
+
+test('setup localtunnel client', function(done) {
+    localtunnel(test._fake_port, function(err, tunnel) {
+        assert.ifError(err);
+        assert.ok(new RegExp('^https:\/\/.*localtunnel.me' + '$').test(tunnel.url));
+        test._fake_url = tunnel.url;
+        done();
+    });
+});
+
+test('query localtunnel server w/ ident', function(done) {
+    var uri = test._fake_url;
+    var parsed = url.parse(uri);
+
+    var opt = {
+        host: parsed.host,
+        port: 443,
+        headers: {
+            host: parsed.hostname
+        },
+        path: '/'
+    };
+
+    var req = https.request(opt, function(res) {
+        res.setEncoding('utf8');
+        var body = '';
+
+        res.on('data', function(chunk) {
+            body += chunk;
+        });
+
+        res.on('end', function() {
+            assert(/.*[.]localtunnel[.]me/.test(body), body);
+            done();
+        });
+    });
+
+    req.end();
+});
+
+test('request specific domain', function(done) {
+    localtunnel(test._fake_port, { subdomain: 'abcd' }, function(err, tunnel) {
+        assert.ifError(err);
+        assert.ok(new RegExp('^https:\/\/abcd.localtunnel.me' + '$').test(tunnel.url));
+        tunnel.close();
+        done();
+    });
+});
+
+suite('--local-host localhost');
+
+test('setup localtunnel client', function(done) {
+    var opt = {
+        local_host: 'localhost'
+    };
+    localtunnel(test._fake_port, opt, function(err, tunnel) {
+        assert.ifError(err);
+        assert.ok(new RegExp('^https:\/\/.*localtunnel.me' + '$').test(tunnel.url));
+        test._fake_url = tunnel.url;
+        done();
+    });
+});
+
+test('override Host header with local-host', function(done) {
+    var uri = test._fake_url;
+    var parsed = url.parse(uri);
+
+    var opt = {
+        host: parsed.host,
+        port: 443,
+        headers: {
+            host: parsed.hostname
+        },
+        path: '/'
+    };
+
+    var req = https.request(opt, function(res) {
+        res.setEncoding('utf8');
+        var body = '';
+
+        res.on('data', function(chunk) {
+            body += chunk;
+        });
+
+        res.on('end', function() {
+            assert.equal(body, 'localhost');
+            done();
+        });
+    });
+
+    req.end();
+});
+
+suite('--local-host 127.0.0.1');
+
+test('setup localtunnel client', function(done) {
+    var opt = {
+        local_host: '127.0.0.1'
+    };
+    localtunnel(test._fake_port, opt, function(err, tunnel) {
+        assert.ifError(err);
+        assert.ok(new RegExp('^https:\/\/.*localtunnel.me' + '$').test(tunnel.url));
+        test._fake_url = tunnel.url;
+        done();
+    });
+});
+
+test('override Host header with local-host', function(done) {
+    var uri = test._fake_url;
+    var parsed = url.parse(uri);
+
+    var opt = {
+        host: parsed.host,
+        port: 443,
+        headers: {
+            host: parsed.hostname
+        },
+        path: '/'
+    };
+
+    var req = https.request(opt, function(res) {
+        res.setEncoding('utf8');
+        var body = '';
+
+        res.on('data', function(chunk) {
+            body += chunk;
+        });
+
+        res.on('end', function() {
+            assert.equal(body, '127.0.0.1');
+            done();
+        });
+    });
+
+    req.end();
+});
+
+test('send chunked request', function(done) {
+    var uri = test._fake_url;
+    var parsed = url.parse(uri);
+
+    var opt = {
+        host: parsed.host,
+        port: 443,
+        headers: {
+            host: parsed.hostname,
+            'Transfer-Encoding': 'chunked'
+        },
+        path: '/'
+    };
+
+    var req = https.request(opt, function(res) {
+        res.setEncoding('utf8');
+        var body = '';
+
+        res.on('data', function(chunk) {
+            body += chunk;
+        });
+
+        res.on('end', function() {
+            assert.equal(body, '127.0.0.1');
+            done();
+        });
+    });
+
+    req.end(require('crypto').randomBytes(1024 * 8).toString('base64'));
+});