twgs-proxy/tcp-proxy.py

#!/usr/bin/env python3

import sys
import re

from twisted.internet import defer
from twisted.internet import protocol
from twisted.internet import reactor
from twisted.internet import task
from twisted.python import log
from twisted.python.logfile import DailyLogFile
import pendulum
from subprocess import check_output
import os
from colorama import Fore, Back, Style

from pprint import pformat

import yaml

def config_load(filename):
    global config
    with open(filename, 'r') as fp:
        config = yaml.safe_load(fp)

if os.path.exists('config_dev.yaml'):
    config_load('config_dev.yaml')
else:
    config_load('config.yaml')

# Extract the version information from git.
# The match gives us only tags starting with v[0-9]*  Using anything else trips up on double digits.
version = check_output(
    [
        "git",
        "describe",
        "--abbrev=8",
        "--long",
        "--tags",
        "--dirty",
        "--always",
        "--match",
        "v[0-9]*",
    ],
    universal_newlines=True,
).strip()


def merge(color_string):
    """ Given a string of colorama ANSI, merge them if you can. """
    return color_string.replace("m\x1b[", ";")


# https://en.wikipedia.org/wiki/ANSI_escape_code

# Cleans all ANSI
cleaner = re.compile(r"\x1b\[[0-9;]*[A-Zmh]")

# Looks for ANSI (that should be considered to be a newline)
# This needs to see what is send when something enters / leaves
# the player's current sector.  (That doesn't work/isn't
# detected.  NNY!)  It is "\x1b[K" Erase in Line!
makeNL = re.compile(r"\x1b\[[0-9;]*[JK]")


def treatAsNL(line):
    """ Replace any ANSI codes that would be better understood as newlines. """
    global makeNL
    return makeNL.sub("\n", line)


def cleanANSI(line):
    """ Remove all ANSI codes. """
    global cleaner
    return cleaner.sub("", line)
    # return re.sub(r'\x1b\[([0-9,A-Z]{1,2}(;[0-9]{1,2})?(;[0-9]{3})?)?[m|K]?', '', line)


from observer import Observer

from flexible import PlayerInput, ProxyMenu


class Game(protocol.Protocol):
    def __init__(self):
        self.buffer = ""
        self.game = None
        self.usergame = (None, None)
        self.to_player = True

    def connectionMade(self):
        log.msg("Connected to Game Server")
        self.queue_player = self.factory.queue_player
        self.queue_game = self.factory.queue_game
        self.observer = self.factory.observer
        self.factory.game = self
        self.setPlayerReceived()
        self.observer.connect("user-game", self.show_game)

    def show_game(self, game):
        self.usergame = game
        log.msg("## User-Game:", game)
        if game[1] is None:
            if hasattr(self, "portdata"):
                log.msg("Clearing out old portdata.")
                self.portdata = {}
            if hasattr(self, "warpdata"):
                log.msg("Clearing out old warpdata.")
                self.warpdata = {}

    def setPlayerReceived(self):
        """ Get deferred from client queue, callback clientDataReceived. """
        self.queue_player.get().addCallback(self.playerDataReceived)

    def playerDataReceived(self, chunk):
        if chunk is False:
            self.queue_player = None
            log.msg("Player: disconnected, close connection to game")
            # I don't believe I need this if I'm using protocol.Factory
            self.factory.continueTrying = False
            self.transport.loseConnection()
        else:
            # Pass received data to the server
            if type(chunk) == str:
                self.transport.write(chunk.encode())
                log.msg(">> [{0}]".format(chunk))
            else:
                self.transport.write(chunk)
                log.msg(">> [{0}]".format(chunk.decode("utf-8", "ignore")))
            self.setPlayerReceived()

    def lineReceived(self, line):
        """ line received from the game. """
        if 'log_lines' in config and config['log_lines']:
            log.msg("<< [{0}]".format(line))

        # if "TWGS v2.20b" in line and "www.eisonline.com" in line:
        # I would still love to "inject" this into the stream
        # so it is consistent.

        # self.queue_game.put(
        #     "TWGS Proxy build "
        #     + version
        #     + " is active. \x1b[1;34m~\x1b[0m to activate.\n\r\n\r",
        # )

        if "TradeWars Game Server" in line and "Copyright (C) EIS" in line:
            # We are not in a game
            if not self.game is None:
                # We were in a game.
                self.game = None
                self.observer.emit("user-game", (self.factory.player.user, self.game))

        if "Selection (? for menu): " in line:
            game = line[-1]
            if game >= "A" and game < "Q":
                self.game = game
                log.msg("Game: {0}".format(self.game))
                self.observer.emit("user-game", (self.factory.player.user, self.game))

        self.observer.emit("game-line", line)

    def getPrompt(self):
        """ Return the current prompt, stripped of ANSI. """
        return cleanANSI(self.buffer)

    def dataReceived(self, chunk):
        """ Data received from the Game. 
        
        Remove backspaces.
        Treat some ANSI codes as NewLine.        
        Remove ANSI.
        Break into lines.
        Trim out carriage returns.
        Call lineReceived().
        
        "Optionally" pass data to player.
        FUTURE: trigger on prompt. [cleanANSI(buffer)]
        """

        # Store the text into the buffer before we inject into it.

        self.buffer += chunk.decode("utf-8", "ignore")
        # log.msg("data: [{0}]".format(repr(chunk)))

        if b"TWGS v2.20b" in chunk and b"www.eisonline.com" in chunk:
            # Ok, we have a possible target.
            target = b"www.eisonline.com\n\r"
            pos = chunk.find(target)
            if pos != -1:
                # Found it!  Inject!
                message = (
                    "TWGS Proxy build " + version + ".  ~ to activate in game.\n\r"
                )
                chunk = (
                    chunk[0 : pos + len(target)]
                    + message.encode()
                    + chunk[pos + len(target) :]
                )

        # Sequence error:
        # If I don't put the chunk(I received) to the player.
        # anything I display -- lineReceive() put() ... would
        # be out of order.  (I'd be responding -- before it
        # was displayed to the user.)

        if self.to_player:
            self.queue_game.put(chunk)

        # self.buffer += chunk.decode("utf-8", "ignore")

        #
        # Begin processing the buffer
        #

        # Process any backspaces
        while "\b" in self.buffer:
            part = self.buffer.partition("\b")
            self.buffer = part[0][:-1] + part[2]

        # Treat some ANSI codes as a newline
        self.buffer = treatAsNL(self.buffer)

        # Break into lines
        while "\n" in self.buffer:
            part = self.buffer.partition("\n")
            line = part[0].replace("\r", "")
            # Clean ANSI codes from line
            line = cleanANSI(line)
            self.lineReceived(line)
            self.buffer = part[2]

        self.observer.emit("prompt", self.getPrompt())

    def connectionLost(self, why):
        log.msg("Game connectionLost because: %s" % why)
        self.observer.emit("close", why)
        self.queue_game.put(False)
        self.transport.loseConnection()


class GlueFactory(protocol.ClientFactory):
    # class GlueFactory(protocol.Factory):
    maxDelay = 10
    protocol = Game

    def __init__(self, player):
        self.player = player
        self.queue_player = player.queue_player
        self.queue_game = player.queue_game
        self.observer = player.observer
        self.game = None

    def closeIt(self):
        log.msg("closeIt")
        self.queue_game.put(False)

    def getUser(self, user):
        log.msg("getUser( %s )" % user)
        self.twgs.logUser(user)

    # This was needed when I replaced ClientFactory with Factory.
    # def clientConnectionLost(self, connector, why):
    #     log.msg("clientconnectionlost: %s" % why)
    #     self.queue_client.put(False)

    def clientConnectionFailed(self, connector, why):
        log.msg("connection to game failed: %s" % why)
        self.queue_game.put(b"Sorry!  I'm Unable to connect to the game server.\r\n")

        # syncterm gets cranky/locks up if we close this here.
        # (Because it is still sending rlogin information?)
        reactor.callLater(2, self.closeIt)


class Player(protocol.Protocol):
    def __init__(self):
        self.buffer = ""
        self.user = None
        self.observer = Observer()
        self.game = None
        self.glue = None

    def connectionMade(self):
        """ connected, setup queues. 
        
        queue_player is data from player.
        queue_game is data to player. (possibly from game)
        """
        self.queue_player = defer.DeferredQueue()
        self.queue_game = defer.DeferredQueue()
        self.setGameReceived()

        # Connect GlueFactory to this Player object.
        factory = GlueFactory(self)
        self.glue = factory

        # Make connection to the game server
        reactor.connectTCP(config['host'], config['port'], factory, 5)

    def setGameReceived(self):
        """ Get deferred from client queue, callback clientDataReceived. """
        self.queue_game.get().addCallback(self.gameDataReceived)

    def gameDataReceived(self, chunk):
        """ Data received from the game. """
        # If we have received game data, it has to be connected.
        if self.game is None:
            self.game = self.glue.game

        if chunk is False:
            self.transport.loseConnection()
        else:
            if type(chunk) == bytes:
                self.transport.write(chunk)
            elif type(chunk) == str:
                self.transport.write(chunk.encode())
            else:
                log.err("gameDataReceived: type (%s) given!".format(type(chunk)))
                self.transport.write(chunk)
            self.setGameReceived()

    def dataReceived(self, chunk):
        if self.user is None:
            self.buffer += chunk.decode("utf-8", "ignore")

            parts = self.buffer.split("\x00")
            if len(parts) >= 5:
                # rlogin we have the username
                self.user = parts[1]
                log.msg("User: {0}".format(self.user))
                zpos = self.buffer.rindex("\x00")
                self.buffer = self.buffer[zpos + 1 :]
                # but I don't need the buffer anymore, so:
                self.buffer = ""
                # Pass user value on to whatever needs it.
                self.observer.emit("user", self.user)
                # Unfortunately, the ones interested in this don't exist yet.

        if not self.observer.emit("player", chunk):
            # Was not dispatched.  Send to game.
            self.queue_player.put(chunk)

        else:
            # There's an observer.  Don't continue.
            return

        if chunk == b"~":
            prompt = self.game.getPrompt()

            # Selection (? for menu):   (the game server menu)
            # Enter your choice:  (game menu)
            # Command [TL=00:00:00]:[1800] (?=Help)? :  <- YES!
            # Computer command [TL=00:00:00]:[613] (?=Help)?
            # (and others I've yet to see...)

            if re.match(r"Command \[TL=.* \(\?=Help\)\? :", prompt):
                menu = ProxyMenu(self.game)
            else:
                nl = "\n\r"
                r = Style.RESET_ALL

                log.msg("NNY!")
                prompt = self.game.buffer
                self.queue_game.put(
                    r
                    + nl
                    + Style.BRIGHT
                    + "Proxy:"
                    + Style.RESET_ALL
                    + " I can't activate at this time."
                    + nl
                )
                self.queue_game.put(prompt)

                self.queue_player.put("\a")
                # self.observer.emit("notyet", prompt)

    def connectionLost(self, why):
        log.msg("lost connection %s" % why)
        self.observer.emit("close", why)
        self.queue_player.put(False)

    def connectionFailed(self, why):
        log.msg("connectionFailed: %s" % why)


if __name__ == "__main__":
    if 'logfile' in config and config['logfile']:
        log.startLogging(DailyLogFile("proxy.log", "."))
    else:
        log.startLogging(sys.stdout)

    log.msg("This is version: %s" % version)
    factory = protocol.Factory()
    factory.protocol = Player
    reactor.listenTCP(config['listen_port'], factory, interface=config['listen_on'])
    reactor.run()
else:
    # I can't seem to get twistd -y tcp-proxy.py 
    # to work.  Missing imports?
    application = service.Application("TradeWarsGameServer-Proxy")
    factory = protocol.Factory()
    factory.protocol = Player
    internet.TCPServer(config['listen_port'], factory).setServiceParent(application)