local.js

// Generated by CoffeeScript 1.10.0
(function() {
  var Encryptor, HTTPPROXY, HttpsProxyAgent, KEY, LOCAL_ADDRESS, METHOD, PORT, REMOTE_PORT, SCHEME, SERVER, WebSocket, config, configContent, configFromArgs, fs, getServer, http, inetNtoa, k, net, options, parseArgs, path, prepareServer, ref, s, server, timeout, url, v;
  net = require('net');
  url = require('url');
  http = require('http');
  fs = require('fs');
  path = require('path');
  WebSocket = require('ws');
  parseArgs = require('minimist');
  HttpsProxyAgent = require('https-proxy-agent');
  Encryptor = require('./encrypt').Encryptor;
  options = {
    alias: {
      'b': 'local_address',
      'l': 'local_port',
      's': 'server',
      'r': 'remote_port',
      'k': 'password',
      'c': 'config_file',
      'm': 'method'
    },
    string: ['local_address', 'server', 'password', 'config_file', 'method', 'scheme'],
    "default": {
      'config_file': path.resolve(__dirname, "config.json")
    }
  };
  inetNtoa = function(buf) {
    return buf[0] + '.' + buf[1] + '.' + buf[2] + '.' + buf[3];
  };
  configFromArgs = parseArgs(process.argv.slice(2), options);
  configContent = fs.readFileSync(configFromArgs.config_file);
  config = JSON.parse(configContent);
  for (k in configFromArgs) {
    v = configFromArgs[k];
    config[k] = v;
  }
  SCHEME = config.scheme;
  SERVER = config.server;
  REMOTE_PORT = config.remote_port;
  LOCAL_ADDRESS = config.local_address;
  PORT = config.local_port;
  KEY = config.password;
  METHOD = config.method;
  timeout = Math.floor(config.timeout * 1000);
  if ((ref = METHOD.toLowerCase()) === '' || ref === 'null' || ref === 'table') {
    METHOD = null;
  }
  HTTPPROXY = process.env.http_proxy;
  if (HTTPPROXY) {
    console.log('http proxy:', HTTPPROXY);
  }
  prepareServer = function(address) {
    var serverUrl;
    serverUrl = url.parse(address);
    serverUrl.slashes = true;
    if (serverUrl.protocol == null) {
      serverUrl.protocol = SCHEME;
    }
    if (serverUrl.hostname === null) {
      serverUrl.hostname = address;
      serverUrl.pathname = '/';
    }
    if (serverUrl.port == null) {
      serverUrl.port = REMOTE_PORT;
    }
    return url.format(serverUrl);
  };
  if (SERVER instanceof Array) {
    SERVER = (function() {
      var j, len, results;
      results = [];
      for (j = 0, len = SERVER.length; j < len; j++) {
        s = SERVER[j];
        results.push(prepareServer(s));
      }
      return results;
    })();
  } else {
    SERVER = prepareServer(SERVER);
  }
  getServer = function() {
    if (SERVER instanceof Array) {
      return SERVER[Math.floor(Math.random() * SERVER.length)];
    } else {
      return SERVER;
    }
  };
  server = net.createServer(function(connection) {
    var aServer, addrLen, addrToSend, cachedPieces, encryptor, headerLength, ping, remoteAddr, remotePort, stage, ws;
    console.log('local connected');
    server.getConnections(function(err, count) {
      if (err) {
        console.log('err:', err);
      }
      // console.log('concurrent connections:', count);
    });
    encryptor = new Encryptor(KEY, METHOD);
    stage = 0;
    headerLength = 0;
    cachedPieces = [];
    addrLen = 0;
    ws = null;
    ping = null;
    remoteAddr = null;
    remotePort = null;
    addrToSend = '';
    aServer = getServer();
    connection.on('data', function(data) {
      var addrtype, agent, buf, cmd, e, endpoint, error, opts, parsed, ref1, reply, tempBuf;
      if (stage === 5) {
        data = encryptor.encrypt(data);
        if (ws.readyState === WebSocket.OPEN) {
          ws.send(data, {
            binary: true
          });
          if (ws.bufferedAmount > 0) {
            connection.pause();
          }
        }
        return;
      }
      if (stage === 0) {
        tempBuf = new Buffer(2);
        tempBuf.write('\u0005\u0000', 0);
        connection.write(tempBuf);
        stage = 1;
        return;
      }
      if (stage === 1) {
        try {
          cmd = data[1];
          addrtype = data[3];
          if (cmd !== 1) {
            console.log('unsupported cmd:', cmd);
            reply = new Buffer('\u0005\u0007\u0000\u0001', 'binary');
            connection.end(reply);
            return;
          }
          if (addrtype === 3) {
            addrLen = data[4];
          } else if (addrtype !== 1) {
            console.log('unsupported addrtype:', addrtype);
            connection.end();
            return;
          }
          addrToSend = data.slice(3, 4).toString('binary');
          if (addrtype === 1) {
            remoteAddr = inetNtoa(data.slice(4, 8));
            addrToSend += data.slice(4, 10).toString('binary');
            remotePort = data.readUInt16BE(8);
            headerLength = 10;
          } else {
            remoteAddr = data.slice(5, 5 + addrLen).toString('binary');
            addrToSend += data.slice(4, 5 + addrLen + 2).toString('binary');
            remotePort = data.readUInt16BE(5 + addrLen);
            headerLength = 5 + addrLen + 2;
          }
          buf = new Buffer(10);
          buf.write('\u0005\u0000\u0000\u0001', 0, 4, 'binary');
          buf.write('\u0000\u0000\u0000\u0000', 4, 4, 'binary');
          buf.writeInt16BE(remotePort, 8);
          connection.write(buf);
          if (HTTPPROXY) {
            endpoint = aServer;
            parsed = url.parse(endpoint);
            opts = url.parse(HTTPPROXY);
            opts.secureEndpoint = (ref1 = parsed.protocol) != null ? ref1 : parsed.protocol === {
              'wss:': false
            };
            agent = new HttpsProxyAgent(opts);
            ws = new WebSocket(aServer, {
              protocol: 'binary',
              agent: agent
            });
          } else {
            ws = new WebSocket(aServer, {
              protocol: 'binary'
            });
          }
          ws.on('open', function() {
            var addrToSendBuf, i, piece;
            ws._socket.on('error', function(e) {
              console.log('remote ' + remoteAddr + ':' + remotePort + ' ' + e);
              connection.destroy();
              return server.getConnections(function(err, count) {
                console.log('concurrent connections:', count);
              });
            });
            console.log('connecting ' + remoteAddr + ' via ' + aServer);
            addrToSendBuf = new Buffer(addrToSend, 'binary');
            addrToSendBuf = encryptor.encrypt(addrToSendBuf);
            ws.send(addrToSendBuf, {
              binary: true
            });
            i = 0;
            while (i < cachedPieces.length) {
              piece = cachedPieces[i];
              piece = encryptor.encrypt(piece);
              ws.send(piece, {
                binary: true
              });
              i++;
            }
            cachedPieces = null;
            stage = 5;
            ping = setInterval(function() {
              return ws.ping('', null, true);
            }, 50 * 1000);
            ws._socket.on('drain', function() {
              return connection.resume();
            });
          });
          ws.on('message', function(data, flags) {
            data = encryptor.decrypt(data);
            if (!connection.write(data)) {
              return ws._socket.pause();
            }
          });
          ws.on('close', function() {
            clearInterval(ping);
            // console.log('remote disconnected');
            return connection.destroy();
          });
          ws.on('error', function(e) {
            console.log('remote ' + remoteAddr + ':' + remotePort + ' error: ' + e);
            connection.destroy();
            return server.getConnections(function(err, count) {
              console.log('concurrent connections:', count);
            });
          });
          if (data.length > headerLength) {
            buf = new Buffer(data.length - headerLength);
            data.copy(buf, 0, headerLength);
            cachedPieces.push(buf);
            buf = null;
          }
          return stage = 4;
        } catch (error) {
          e = error;
          console.log(e);
          return connection.destroy();
        }
      } else {
        if (stage === 4) {
          return cachedPieces.push(data);
        }
      }
    });
    connection.on('end', function() {
      console.log('local disconnected');
      if (ws) {
        ws.terminate();
      }
      return server.getConnections(function(err, count) {
        console.log('concurrent connections:', count);
      });
    });
    connection.on('error', function(e) {
      console.log('local error: ' + e);
      if (ws) {
        ws.terminate();
      }
      return server.getConnections(function(err, count) {
        console.log('concurrent connections:', count);
      });
    });
    connection.on('drain', function() {
      if (ws && ws._socket) {
        return ws._socket.resume();
      }
    });
    return connection.setTimeout(timeout, function() {
      console.log('local timeout');
      connection.destroy();
      if (ws) {
        return ws.terminate();
      }
    });
  });
  server.listen(PORT, LOCAL_ADDRESS, function() {
    var address;
    address = server.address();
    return console.log('server listening at', address);
  });
  server.on('error', function(e) {
    if (e.code === 'EADDRINUSE') {
      console.log('address in use, aborting');
    }
    return process.exit(1);
  });
}).call(this);