enigma-bbs/core/bbs_link.js

/* jslint node: true */
'use strict';

const MenuModule	= require('./menu_module.js').MenuModule;
const resetScreen	= require('./ansi_term.js').resetScreen;

const async			= require('async');
const _				= require('lodash');
const http			= require('http');
const net			= require('net');
const crypto		= require('crypto');

const packageJson 	= require('../package.json');

/*
	Expected configuration block:

	{
		module: bbs_link
		...
		config: {
			sysCode: XXXXX
			authCode: XXXXX
			schemeCode: XXXX
			door: lord
			
			//	default hoss: games.bbslink.net
			host: games.bbslink.net
			
			//	defualt port: 23
			port: 23
		}
	}
*/

//	:TODO: BUG: When a client disconnects, it's not handled very well -- the log is spammed with tons of errors
//	:TODO: ENH: Support nodeMax and tooManyArt

exports.moduleInfo = {
	name	: 'BBSLink',
	desc	: 'BBSLink Access Module',
	author	: 'NuSkooler',
};

exports.getModule = class BBSLinkModule extends MenuModule {
	constructor(options) {
		super(options);

		this.config			= options.menuConfig.config;
		this.config.host	= this.config.host || 'games.bbslink.net';
		this.config.port	= this.config.port || 23;
	}	

	initSequence() {
		let token;
		let randomKey;
		let clientTerminated;
		const self = this;

		async.series(
			[
				function validateConfig(callback) {
					if(_.isString(self.config.sysCode) &&
						_.isString(self.config.authCode) &&
						_.isString(self.config.schemeCode) &&
						_.isString(self.config.door))
					{
						callback(null);
					} else {
						callback(new Error('Configuration is missing option(s)'));
					}
				},
				function acquireToken(callback) {
					//
					//	Acquire an authentication token
					//
					crypto.randomBytes(16, function rand(ex, buf) {
						if(ex) {
							callback(ex);
						} else {
							randomKey = buf.toString('base64').substr(0, 6);
							self.simpleHttpRequest('/token.php?key=' + randomKey, null, function resp(err, body) {
								if(err) {
									callback(err);
								} else {
									token = body.trim();
									self.client.log.trace( { token : token }, 'BBSLink token');
									callback(null);
								}
							});
						}
					});
				},
				function authenticateToken(callback) {
					//
					//	Authenticate the token we acquired previously
					//
					var headers = {
						'X-User'	: self.client.user.userId.toString(),
						'X-System'	: self.config.sysCode,
						'X-Auth'	: crypto.createHash('md5').update(self.config.authCode + token).digest('hex'),
						'X-Code'	: crypto.createHash('md5').update(self.config.schemeCode + token).digest('hex'),
						'X-Rows'	: self.client.term.termHeight.toString(),
						'X-Key'		: randomKey,
						'X-Door'	: self.config.door,
						'X-Token'	: token,
						'X-Type'	: 'enigma-bbs',
						'X-Version'	: packageJson.version,
					};

					self.simpleHttpRequest('/auth.php?key=' + randomKey, headers, function resp(err, body) {
						var status = body.trim();

						if('complete' === status) {
							callback(null);
						} else {
							callback(new Error('Bad authentication status: ' + status));
						}
					});
				},
				function createTelnetBridge(callback) {
					//
					//	Authentication with BBSLink successful. Now, we need to create a telnet
					//	bridge from us to them
					//
					var connectOpts = {
						port	: self.config.port,
						host	: self.config.host,
					};

					var clientTerminated;

					self.client.term.write(resetScreen());
					self.client.term.write('  Connecting to BBSLink.net, please wait...\n');

					var bridgeConnection = net.createConnection(connectOpts, function connected() {
						self.client.log.info(connectOpts, 'BBSLink bridge connection established');

						self.client.term.output.pipe(bridgeConnection);

						self.client.once('end', function clientEnd() {
							self.client.log.info('Connection ended. Terminating BBSLink connection');
							clientTerminated = true;
							bridgeConnection.end();						
						});
					});

					var restorePipe = function() {
						self.client.term.output.unpipe(bridgeConnection);
						self.client.term.output.resume();
					};

					bridgeConnection.on('data', function incomingData(data) {
						//	pass along
						//	:TODO: just pipe this as well
						self.client.term.rawWrite(data);
					});

					bridgeConnection.on('end', function connectionEnd() {
						restorePipe();
						callback(clientTerminated ? new Error('Client connection terminated') : null);
					});

					bridgeConnection.on('error', function error(err) {
						self.client.log.info('BBSLink bridge connection error: ' + err.message);
						restorePipe();
						callback(err);
					});
				}
			],
			function complete(err) {
				if(err) {
					self.client.log.warn( { error : err.toString() }, 'BBSLink connection error');					
				}

				if(!clientTerminated) {
					self.prevMenu();
				}
			}
		);
	}

	simpleHttpRequest(path, headers, cb) {
		const getOpts = {
			host	: this.config.host,
			path	: path,
			headers	: headers,
		};

		const req = http.get(getOpts, function response(resp) {
			let data = '';

			resp.on('data', function chunk(c) {
				data += c;
			});

			resp.on('end', function respEnd() {
				cb(null, data);
				req.end();
			});
		});

		req.on('error', function reqErr(err) {
			cb(err);
		});
	}
};