enigma-bbs/core/servers/login/websocket.js

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

//  ENiGMA½
const Config            = require('../../config.js').get;
const TelnetClient      = require('./telnet.js').TelnetClient;
const Log               = require('../../logger.js').log;
const LoginServerModule = require('../../login_server_module.js');
const { Errors }        = require('../../enig_error.js');

//  deps
const _                 = require('lodash');
const WebSocketServer   = require('ws').Server;
const http              = require('http');
const https             = require('https');
const fs                = require('graceful-fs');
const { Duplex } = require('stream');
const forEachSeries     = require('async/forEachSeries');

const ModuleInfo = exports.moduleInfo = {
    name        : 'WebSocket',
    desc        : 'WebSocket Server',
    author      : 'NuSkooler',
    packageName : 'codes.l33t.enigma.websocket.server',
};

class WebSocketClient extends TelnetClient {
    constructor(ws, req, serverType) {
        //  allow WebSocket to act like a Duplex (socket)
        const wsDuplex = new class WebSocketDuplex extends Duplex {
            constructor(ws) {
                super();
                this.ws = ws;

                this.ws.on('close', err => this.emit('close', err));
                this.ws.on('error', err => this.emit('error', err));
                this.ws.on('message', data => this._data(data));
            }

            setClient(client, httpRequest) {
                this.client = client;

                //  Support X-Forwarded-For and X-Real-IP headers for proxied connections
                this.resolvedRemoteAddress =
                    (this.client.proxied && (httpRequest.headers['x-forwarded-for'] || httpRequest.headers['x-real-ip'])) ||
                    httpRequest.connection.remoteAddress;
            }

            get remoteAddress() {
                return  this.resolvedRemoteAddress;
            }

            _write(data, encoding, cb) {
                cb = cb || ( () => { /* eat it up */} );    //  handle data writes after close
                return this.ws.send(data, { binary : true }, cb);
            }

            _read() {
                //  dummy
            }

            _data(data) {
                this.push(data);
            }
        }(ws);

        super(wsDuplex);
        wsDuplex.setClient(this, req);

        //  fudge remoteAddress on socket, which is now TelnetSocket
        this.socket.remoteAddress = wsDuplex.remoteAddress;

        wsDuplex.on('close', () => {
            //  we'll remove client connection which will in turn end() via our SocketBridge above
            return this.emit('end');
        });

        this.serverType = serverType;

        //
        //  Monitor connection status with ping/pong
        //
        ws.on('pong', () => {
            Log.trace(`Pong from ${wsDuplex.remoteAddress}`);
            ws.isConnectionAlive = true;
        });

        Log.trace( { headers : req.headers }, 'WebSocket connection headers' );

        //
        //  If the config allows it, look for 'x-forwarded-proto' as "https"
        //  to override |isSecure|
        //
        if(true === _.get(Config(), 'loginServers.webSocket.proxied') &&
            'https' === req.headers['x-forwarded-proto'])
        {
            Log.debug(`Assuming secure connection due to X-Forwarded-Proto of "${req.headers['x-forwarded-proto']}"`);
            this.proxied = true;
        } else {
            this.proxied = false;
        }

        //  start handshake process
        this.banner();
    }

    get isSecure() {
        return ('secure' === this.serverType || true === this.proxied) ? true : false;
    }
}

const WSS_SERVER_TYPES = [ 'insecure', 'secure' ];

exports.getModule = class WebSocketLoginServer extends LoginServerModule {
    constructor() {
        super();
    }

    createServer(cb) {
        //
        //  We will actually create up to two servers:
        //  * insecure websocket (ws://)
        //  * secure (tls) websocket (wss://)
        //
        const config = _.get(Config(), 'loginServers.webSocket');
        if(!_.isObject(config)) {
            return cb(null);
        }

        const wsPort    = _.get(config, 'ws.port');
        const wssPort   = _.get(config, 'wss.port');

        if(true === _.get(config, 'ws.enabled') && _.isNumber(wsPort)) {
            const httpServer = http.createServer( (req, resp) => {
                //  dummy handler
                resp.writeHead(200);
                return resp.end('ENiGMA½ BBS WebSocket Server!');
            });

            this.insecure = {
                httpServer  : httpServer,
                wsServer    : new WebSocketServer( { server : httpServer } ),
            };
        }

        if(_.isObject(config, 'wss') && true === _.get(config, 'wss.enabled') && _.isNumber(wssPort)) {
            const httpServer = https.createServer({
                key     : fs.readFileSync(config.wss.keyPem),
                cert    : fs.readFileSync(config.wss.certPem),
            });

            this.secure = {
                httpServer  : httpServer,
                wsServer    : new WebSocketServer( { server : httpServer } ),
            };
        }

        return cb(null);
    }

    listen(cb) {
        //
        //  Send pings every 30s
        //
        setInterval( () => {
            WSS_SERVER_TYPES.forEach(serverType => {
                if(this[serverType]) {
                    this[serverType].wsServer.clients.forEach(ws => {
                        if(false === ws.isConnectionAlive) {
                            Log.debug('WebSocket connection seems inactive. Terminating.');
                            return ws.terminate();
                        }

                        ws.isConnectionAlive = false;   //  pong will reset this

                        Log.trace('Ping to remote WebSocket client');
                        try {
                            ws.ping('', false);  //  false=don't mask
                        } catch(e) {    //  don't barf on closing state
                            /* nothing */
                        }
                    });
                }
            });
        }, 30000);

        forEachSeries(WSS_SERVER_TYPES, (serverType, nextServerType) => {
            const server = this[serverType];
            if(!server) {
                return nextServerType(null);
            }

            const serverName    = `${ModuleInfo.name} (${serverType})`;
            const conf          = _.get(Config(), [ 'loginServers', 'webSocket', 'secure' === serverType ? 'wss' : 'ws' ] );
            const confPort      = conf.port;
            const port          = parseInt(confPort);

            if(isNaN(port)) {
                Log.error( { server : serverName, port : confPort }, 'Cannot load server (invalid port)' );
                return nextServerType(Errors.Invalid(`Invalid port: ${confPort}`));
            }

            server.httpServer.listen(port, conf.address, err => {
                if(err) {
                    return nextServerType(err);
                }

                server.wsServer.on('connection', (ws, req) => {
                    const webSocketClient = new WebSocketClient(ws, req, serverType);
                    this.handleNewClient(webSocketClient, webSocketClient.socket, ModuleInfo);
                });

                Log.info( { server : serverName, port : port }, 'Listening for connections' );
                return nextServerType(null);
            });
        },
        err => {
            cb(err);
        });
    }
};