168 lines
4.2 KiB
JavaScript
Executable file
168 lines
4.2 KiB
JavaScript
Executable file
#!/usr/bin/env node
|
|
|
|
var nconf = require('nconf');
|
|
var yargs = require('yargs');
|
|
var fs = require('fs');
|
|
var TorRouter = require('../');
|
|
var SOCKSServer = TorRouter.SOCKSServer;
|
|
var DNSServer = TorRouter.DNSServer;
|
|
var TorPool = TorRouter.TorPool;
|
|
var ControlServer = TorRouter.ControlServer;
|
|
var winston = require('winston');
|
|
var async = require('async');
|
|
|
|
process.title = 'tor-router';
|
|
|
|
let package_json = JSON.parse(fs.readFileSync(`${__dirname}/../package.json`, 'utf8'));
|
|
|
|
let argv_config = require('yargs')
|
|
.version(package_json.version)
|
|
.usage('Usage: tor-router [arguments]')
|
|
.options({
|
|
f: {
|
|
alias: 'config',
|
|
describe: 'Path to a config file to use',
|
|
demand: false
|
|
},
|
|
c: {
|
|
alias: 'controlPort',
|
|
describe: 'Port the control server will bind to [default: 9077]',
|
|
demand: false
|
|
// ,default: 9077
|
|
},
|
|
j: {
|
|
alias: 'instances',
|
|
describe: 'Number of instances using the default config',
|
|
demand: false
|
|
// ,default: 1
|
|
},
|
|
s: {
|
|
alias: 'socksPort',
|
|
describe: 'Port the SOCKS5 Proxy server will bind to',
|
|
demand: false,
|
|
// ,default: 9050
|
|
},
|
|
d: {
|
|
alias: 'dnsPort',
|
|
describe: 'Port the DNS Proxy server will bind to',
|
|
demand: false
|
|
},
|
|
h: {
|
|
alias: 'httpPort',
|
|
describe: 'Port the HTTP Proxy server will bind to',
|
|
demand: false
|
|
},
|
|
l: {
|
|
alias: 'logLevel',
|
|
describe: 'Controls the verbosity of console log output. Default level is "info". Set to "verbose" to see all network traffic logged or "null" to disable logging completely [default: info]',
|
|
demand: false
|
|
// ,default: "info"
|
|
},
|
|
p: {
|
|
alias: 'parentDataDirectory',
|
|
describe: 'Parent directory that will contain the data directories for the instances',
|
|
demand: false
|
|
},
|
|
b: {
|
|
alias: "loadBalanceMethod",
|
|
describe: 'Method that will be used to sort the instances between each request. Currently supports "round_robin" and "weighted". [default: round_robin]',
|
|
demand: false
|
|
},
|
|
t: {
|
|
alias: "torPath",
|
|
describe: "Provide the path for the Tor executable that will be used",
|
|
demand: false
|
|
}
|
|
});
|
|
|
|
|
|
nconf = require(`${__dirname}/../src/nconf_load_env.js`)(nconf);
|
|
nconf
|
|
.argv(argv_config);
|
|
|
|
let nconf_config = nconf.get('config');
|
|
if (nconf_config) {
|
|
nconf.file(nconf_config);
|
|
}
|
|
|
|
nconf.defaults(require(`${__dirname}/../src/default_config.js`))
|
|
|
|
let logLevel = nconf.get('logLevel');
|
|
|
|
var logger = null;
|
|
logger = winston.createLogger({
|
|
level: logLevel,
|
|
format: winston.format.simple(),
|
|
transports: (logLevel == 'null') ? [ new (require('winston-null-transport'))() ] : [ new (winston.transports.Console)({ level: logLevel }) ]
|
|
});
|
|
|
|
|
|
let instances = nconf.get('instances');
|
|
let log_level = logLevel;
|
|
let socks_port = nconf.get('socksPort');
|
|
let dns_port = nconf.get('dnsPort');
|
|
let http_port = nconf.get('httpPort');
|
|
let control_port = nconf.get('controlPort');
|
|
|
|
if (typeof(control_port) === 'boolean') {
|
|
control_port = 9077;
|
|
nconf.set('controlPort', 9077);
|
|
}
|
|
|
|
let control = new ControlServer(logger, nconf);
|
|
|
|
process.on('SIGHUP', () => {
|
|
control.torPool.new_ips();
|
|
});
|
|
|
|
if (socks_port) {
|
|
if (typeof(socks_port) === 'boolean') {
|
|
socks_port = 9050;
|
|
nconf.set('socksPort', socks_port);
|
|
}
|
|
let socks = control.createSOCKSServer(socks_port);
|
|
}
|
|
|
|
if (http_port) {
|
|
if (typeof(http_port) === 'boolean') {
|
|
http_port = 9080;
|
|
nconf.set('httpPort', http_port);
|
|
}
|
|
let http = control.createHTTPServer(http_port);
|
|
}
|
|
|
|
if (dns_port) {
|
|
if (typeof(dns_port) === 'boolean') {
|
|
dns_port = 9053;
|
|
nconf.set('dnsPort', dns_port);
|
|
}
|
|
let dns = control.createDNSServer(dns_port);
|
|
}
|
|
|
|
if (instances) {
|
|
logger.info(`[tor]: starting ${Array.isArray(instances) ? instances.length : instances} tor instances...`)
|
|
control.torPool.create(instances, (err) => {
|
|
logger.info('[tor]: tor started');
|
|
});
|
|
}
|
|
|
|
control.listen(control_port, () => {
|
|
logger.info(`[control]: Control Server listening on ${control_port}`);
|
|
})
|
|
|
|
function cleanUp(error) {
|
|
async.each(control.torPool.instances, (instance, next) => {
|
|
instance.exit(next);
|
|
}, (exitError) => {
|
|
if (error) {
|
|
console.error(error.stack);
|
|
}
|
|
if (exitError){
|
|
console.error(exitError);
|
|
}
|
|
process.exit(Number(Boolean(error || exitError)));
|
|
});
|
|
}
|
|
process.on('exit', cleanUp);
|
|
process.on('SIGINT', cleanUp);
|
|
process.on('uncaughtException', cleanUp); |