enigma-bbs/core/telnet_bridge.js

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

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

//	deps
const async			= require('async');
const _				= require('lodash');
const net			= require('net');
const EventEmitter	= require('events');
const buffers		= require('buffers');

/*
	Expected configuration block:

	{
		module: telnet_bridge
		...
		config: {
			host: somehost.net
			port: 23
		}
	}
*/

//	:TODO: ENH: Support nodeMax and tooManyArt
exports.moduleInfo = {
    name	: 'Telnet Bridge',
    desc	: 'Connect to other Telnet Systems',
    author	: 'Andrew Pamment',
};

const IAC_DO_TERM_TYPE = Buffer.from( [ 255, 253, 24 ] );

class TelnetClientConnection extends EventEmitter {
    constructor(client) {
        super();

        this.client		= client;
    }


    restorePipe() {
        if(!this.pipeRestored) {
            this.pipeRestored = true;

            //	client may have bailed
            if(null !== _.get(this, 'client.term.output', null)) {
                if(this.bridgeConnection) {
                    this.client.term.output.unpipe(this.bridgeConnection);
                }
                this.client.term.output.resume();
            }
        }
    }

    connect(connectOpts) {
        this.bridgeConnection = net.createConnection(connectOpts, () => {
            this.emit('connected');

            this.pipeRestored = false;
            this.client.term.output.pipe(this.bridgeConnection);
        });

        this.bridgeConnection.on('data', data => {
            this.client.term.rawWrite(data);

            //
            //	Wait for a terminal type request, and send it eactly once.
            //	This is enough (in additional to other negotiations handled in telnet.js)
            //	to get us in on most systems
            //
            if(!this.termSent && data.indexOf(IAC_DO_TERM_TYPE) > -1) {
                this.termSent = true;
                this.bridgeConnection.write(this.getTermTypeNegotiationBuffer());
            }
        });

        this.bridgeConnection.once('end', () => {
            this.restorePipe();
            this.emit('end');
        });

        this.bridgeConnection.once('error', err => {
            this.restorePipe();
            this.emit('end', err);
        });
    }

    disconnect() {
        if(this.bridgeConnection) {
            this.bridgeConnection.end();
        }
    }

    destroy() {
        if(this.bridgeConnection) {
            this.bridgeConnection.destroy();
            this.bridgeConnection.removeAllListeners();
            this.restorePipe();
            this.emit('end');
        }
    }

    getTermTypeNegotiationBuffer() {
        //
        //	Create a TERMINAL-TYPE sub negotiation buffer using the
        //	actual/current terminal type.
        //
        let bufs = buffers();

        bufs.push(Buffer.from(
            [
                255,	//	IAC
                250,	//	SB
                24,		//	TERMINAL-TYPE
                0,		//	IS
            ]
        ));

        bufs.push(
            Buffer.from(this.client.term.termType),	//	e.g. "ansi"
            Buffer.from( [ 255, 240 ] )				//	IAC, SE
        );

        return bufs.toBuffer();
    }

}

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

        this.config			= Object.assign({}, _.get(options, 'menuConfig.config'), options.extraArgs);
        this.config.port	= this.config.port || 23;
    }

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

        async.series(
            [
                function validateConfig(callback) {
                    if(_.isString(self.config.host) &&
						_.isNumber(self.config.port))
                    {
                        callback(null);
                    } else {
                        callback(new Error('Configuration is missing required option(s)'));
                    }
                },
                function createTelnetBridge(callback) {
                    const connectOpts = {
                        port	: self.config.port,
                        host	: self.config.host,
                    };

                    self.client.term.write(resetScreen());
                    self.client.term.write(
                        `  Connecting to ${connectOpts.host}, please wait...\n  (Press ESC to cancel)\n`
                    );

                    const telnetConnection = new TelnetClientConnection(self.client);

                    const connectionKeyPressHandler = (ch, key) => {
                        if('escape' === key.name) {
                            self.client.removeListener('key press', connectionKeyPressHandler);
                            telnetConnection.destroy();
                        }
                    };

                    self.client.on('key press', connectionKeyPressHandler);

                    telnetConnection.on('connected', () => {
                        self.client.removeListener('key press', connectionKeyPressHandler);
                        self.client.log.info(connectOpts, 'Telnet bridge connection established');

                        if(self.config.font) {
                            self.client.term.rawWrite(setSyncTermFontWithAlias(self.config.font));
                        }

                        self.client.once('end', () => {
                            self.client.log.info('Connection ended. Terminating connection');
                            clientTerminated = true;
                            telnetConnection.disconnect();
                        });
                    });

                    telnetConnection.on('end', err => {
                        self.client.removeListener('key press', connectionKeyPressHandler);

                        if(err) {
                            self.client.log.info(`Telnet bridge connection error: ${err.message}`);
                        }

                        callback(clientTerminated ? new Error('Client connection terminated') : null);
                    });

                    telnetConnection.connect(connectOpts);
                }
            ],
            err => {
                if(err) {
                    self.client.log.warn( { error : err.message }, 'Telnet connection error');
                }

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