Server/src/engine/net/client/ClientConnection.java

// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
//      Magicbane Emulator Project © 2013 - 2022
//                www.magicbane.com


package engine.net.client;

import engine.Enum;
import engine.gameManager.ConfigManager;
import engine.gameManager.SessionManager;
import engine.job.JobScheduler;
import engine.jobs.DisconnectJob;
import engine.net.AbstractConnection;
import engine.net.AbstractNetMsg;
import engine.net.Network;
import engine.net.client.msg.ClientNetMsg;
import engine.net.client.msg.login.LoginErrorMsg;
import engine.objects.Account;
import engine.objects.PlayerCharacter;
import engine.server.MBServerStatics;
import engine.session.SessionID;
import org.pmw.tinylog.Logger;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.NotYetConnectedException;
import java.nio.channels.SocketChannel;
import java.util.concurrent.locks.ReentrantLock;

public class ClientConnection extends AbstractConnection {

    private final ClientAuthenticator crypto;
    private final String clientIpAddress;
    public String machineID;
    public long guildtreespam = 0;
    public long ordernpcspam = 0;
    public ReentrantLock trainLock = new ReentrantLock();
    public ReentrantLock sellLock = new ReentrantLock();
    public ReentrantLock buyLock = new ReentrantLock();
    public boolean desyncDebug = false;
    public byte[] lastByteBuffer;
    protected SessionID sessionID = null;
    private byte cryptoInitTries = 0;

    public ClientConnection(ClientConnectionManager connMan,
                            SocketChannel sockChan) {
        super(connMan, sockChan, true);
        this.crypto = new ClientAuthenticator(this);

        this.clientIpAddress = sockChan.socket().getRemoteSocketAddress()
                .toString().replace("/", "").split(":")[0];
    }

    @Override
    protected boolean _sendMsg(AbstractNetMsg msg) {
        try {
            msg.setOrigin(this);
            ByteBuffer bb = msg.serialize();

            // Application protocol logging toggled via
            // DevCmd: netdebug on|off

            if (MBServerStatics.DEBUG_PROTOCOL)
                applicationProtocolLogger(msg, MessageSource.SOURCE_SERVER);

            boolean retval = this.sendBB(bb);
            Network.byteBufferPool.putBuffer(bb);//return here.

            return retval;

        } catch (Exception e) { // Catch-all
            Logger.error(e);
            return false;
        }
    }

    /**
     * Sending a NetMsg to the client involves NOT including a dataLen parameter
     * and also involves encrypting the data.
     */
    @Override
    protected boolean _sendBB(ByteBuffer bb) {
        boolean useCrypto = this.crypto.initialized();
        boolean retVal;

        // Logger.debug("useCrypto: " + useCrypto + ". bb.cap(): " +
        // bb.capacity());
        if (useCrypto == false)
            retVal = super._sendBB(bb);
        else {
            if (bb == null)
                Logger.error("Incoming bb is null");
            ByteBuffer encrypted = Network.byteBufferPool.getBufferToFit(bb.capacity());
            if (encrypted == null)
                Logger.error("Encrypted bb is null");
            this.crypto.encrypt(bb, encrypted);
            retVal = super._sendBB(encrypted);
        }

        return retVal;
    }

    /**
     * Receiving data from a client involves the initial Crypto Key Exchange,
     * waiting for a complete NetMsg to arrive using an accumulation factory and
     * decrypting the data.
     */
    //FIXME the int return value on this means nothing!  Clean it up!
    @Override
    protected int read() {

        if (readLock.tryLock())
            try {

                // First and foremost, check to see if we the Crypto is initted yet
                if (!this.crypto.initialized())
                    this.crypto.initialize(this);

                if (!this.crypto.initialized()) {
                    ++this.cryptoInitTries;
                    if (this.cryptoInitTries >= MBServerStatics.MAX_CRYPTO_INIT_TRIES) {
                        Logger.info("Failed to initialize after "
                                + MBServerStatics.MAX_CRYPTO_INIT_TRIES
                                + " tries. Disconnecting.");
                        this.disconnect();
                    }
                    return 0;
                }

                // check to see if SessionID == null;
                if (this.sessionID == null)
                    this.sessionID = new SessionID(this.crypto.getSecretKeyBytes());

                // Get ByteBuffers out of pool.
                ByteBuffer bb = Network.byteBufferPool.getBuffer(16);
                ByteBuffer decrypted = Network.byteBufferPool.getBuffer(16);
                // ByteBuffer bb = ByteBuffer.allocate(1024 * 4);

                int totalBytesRead = 0;
                int lastRead = 0;
                do {
                    try {
                        bb.clear();
                        decrypted.clear();
                        lastRead = this.sockChan.read(bb);
                        // On EOF on the SocketChannel, disconnect.
                        if (lastRead <= -1) {
                            this.disconnect();
                            break;
                        }

                        if (lastRead == 0)
                            continue;

                        // ByteBuffer decrypted = ByteBuffer.allocate(lastRead);
                        this.crypto.decrypt(bb, decrypted);
                        this.factory.addData(decrypted);


                        this.checkInternalFactory();

                        totalBytesRead += lastRead;


                    } catch (NotYetConnectedException e) {
                        Logger.error(e.getLocalizedMessage());
                        totalBytesRead = -1; // Set error retVal
                        break;

                    } catch (ClosedChannelException e) {
                        // TODO Should a closed channel be logged or just cleaned up?
                        // this.logEXCEPTION(e);
                        this.disconnect();
                        totalBytesRead = -1; // Set error retVal
                        break;

                    } catch (IOException e) {
                        if (e.getLocalizedMessage() != null && (!e.getLocalizedMessage().equals(MBServerStatics.EXISTING_CONNECTION_CLOSED) && !e.getLocalizedMessage().equals(MBServerStatics.RESET_BY_PEER))) {
                            Logger.info("Error Reading message opcode " + this.lastOpcode);
                            Logger.error(e);
                        }
                        this.disconnect();
                        totalBytesRead = -1; // Set error retVal
                        break;

                    } catch (Exception e) {
                        Logger.info("Error Reading message opcode " + this.lastOpcode);
                        Logger.error(e);
                        totalBytesRead = -1; // Set error retVal
                        this.disconnect();
                        break;
                    }
                }

                while (lastRead > 0);

                Network.byteBufferPool.putBuffer(bb);
                Network.byteBufferPool.putBuffer(decrypted);

                return totalBytesRead;

            } finally {
                readLock.unlock();
            }
        else {
            Logger.debug("Another thread already has a read lock! Skipping.");
            return 0;
        }
    }

    @Override
    public void disconnect() {
        super.disconnect();
        try {

            if (ConfigManager.serverType.equals(Enum.ServerType.WORLDSERVER))
                ConfigManager.worldServer.removeClient(this);
            else
                ConfigManager.loginServer.removeClient(this);

            // TODO There has to be a more direct way to do this...
            SessionManager.remSession(
                    SessionManager.getSession(sessionID));
        } catch (NullPointerException e) {
            Logger
                    .error(
                            "Tried to remove improperly initialized session. Skipping." +
                                    e);
        }
    }

    public void forceDisconnect() {
        super.disconnect();
    }

    public SessionID getSessionID() {
        return sessionID;
    }

    /*
     * Getters n setters
     */

    public byte[] getSecretKeyBytes() {
        return this.crypto.getSecretKeyBytes();
    }

    /*
     * Convenience getters for SessionManager
     */
    public Account getAccount() {
        return SessionManager.getAccount(this);
    }

    public PlayerCharacter getPlayerCharacter() {
        return SessionManager.getPlayerCharacter(this);
    }

    @Override
    public boolean handleClientMsg(ClientNetMsg msg) {

        Protocol protocolMsg = msg.getProtocolMsg();

        switch (protocolMsg) {
            case KEEPALIVESERVERCLIENT:
                this.setLastKeepAliveTime();
                break;
            //           case ClientOpcodes.OpenVault:
            //           case ClientOpcodes.Random:
            //           case ClientOpcodes.DoorTryOpen:
            //           case ClientOpcodes.SetSelectedObect:
            //           case ClientOpcodes.MoveObjectToContainer:
            //            case ClientOpcodes.ToggleSitStand:
            //            case ClientOpcodes.SocialChannel:
            //            case ClientOpcodes.OpenFriendsCondemnList:
            case SELLOBJECT:
                this.setLastMsgTime();
                break;
            case MOVETOPOINT:
            case ARCCOMBATMODEATTACKING:
                this.setLastMsgTime();
                break;
            default:
                this.setLastMsgTime();
                break;
        }

        // Application protocol logging toggled via
        // DevCmd: netdebug on|off

        if (MBServerStatics.DEBUG_PROTOCOL)
            applicationProtocolLogger(msg, MessageSource.SOURCE_CLIENT);

        return ConfigManager.handler.handleClientMsg(msg); // *** Refactor : Null check then call
    }

    private void applicationProtocolLogger(AbstractNetMsg msg, MessageSource origin) {

        String outString = "";
        PlayerCharacter tempPlayer = null;

        // Log the protocolMsg
        if (origin == MessageSource.SOURCE_CLIENT)
            outString = " Incoming protocolMsg: ";
        else
            outString = " Outgoing protocolMsg: ";

        Logger.info(outString
                + Integer.toHexString(msg.getProtocolMsg().opcode)
                + '/' + msg.getProtocolMsg());

        // Dump message contents using reflection
        tempPlayer = this.getPlayerCharacter();
        outString = "";
        outString += (tempPlayer == null) ? "PlayerUnknown" : tempPlayer.getFirstName() + ' '
                + msg.toString();
        Logger.info(outString);
    }
    // Method logs detailed information about application
    // protocol traffic.  Toggled at runtime via the
    // DevCmd netdebug on|off

    public void kickToLogin(int errCode, String message) {

        LoginErrorMsg lom = new LoginErrorMsg(errCode, message);

        if (!sendMsg(lom))
            Logger.error("Failed to send  message"); // TODO Do we just accept this failure to send Msg?

        DisconnectJob dj = new DisconnectJob(this);
        JobScheduler.getInstance().scheduleJob(dj, 250);

    }

    public final String getClientIpAddress() {
        return this.clientIpAddress;
    }

    // Enumeration of a message's origin for logging purposes
    private enum MessageSource {

        SOURCE_CLIENT,
        SOURCE_SERVER
    }
}