ClientSocket.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff
 * Copyright (C) 2006-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
package com.realtime.crossfire.jxclient.server.socket;
 
import com.realtime.crossfire.jxclient.guistate.GuiStateManager;
import com.realtime.crossfire.jxclient.util.DebugWriter;
import com.realtime.crossfire.jxclient.util.EventListenerList2;
import java.io.EOFException;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.SocketException;
import java.nio.Buffer;
import java.nio.BufferOverflowException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.UnresolvedAddressException;
import java.util.Collection;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class ClientSocket {
 
    private static final int MAXIMUM_PACKET_SIZE = 65536;
 
    @NotNull
    private final GuiStateManager guiStateManager;
 
    @Nullable
    private final DebugWriter debugProtocol;
 
    @NotNull
    private final EventListenerList2<ClientSocketListener> clientSocketListeners = new EventListenerList2<>();
 
    @NotNull
    private final Selector selector;
 
    @NotNull
    private final Object syncConnect = new Object();
 
    private boolean reconnect = true;
 
    @NotNull
    private String reconnectReason = "disconnect";
 
    private boolean reconnectIsError;
 
    @Nullable
    private String host;
 
    private int port;
 
    private boolean disconnectPending;
 
    private final byte @NotNull [] packetHeader = new byte[2];
 
    @Nullable
    private SelectableChannel selectableChannel;
 
    @Nullable
    private SelectionKey selectionKey;
 
    private int interestOps;
 
    private final byte @NotNull [] inputBuf = new byte[2+MAXIMUM_PACKET_SIZE];
 
    @NotNull
    private final ByteBuffer inputBuffer = ByteBuffer.wrap(inputBuf);
 
    private int inputLen = -1;
 
    @NotNull
    private final Object syncOutput = new Object();
 
    @NotNull
    private final ByteBuffer outputBuffer = ByteBuffer.allocate(2+MAXIMUM_PACKET_SIZE);
 
    @Nullable
    private SocketChannel socketChannel;
 
    private boolean isConnected;
 
    @NotNull
    private final Thread thread = new Thread(this::process, "JXClient:ClientSocket");
 
    public ClientSocket(@NotNull final GuiStateManager guiStateManager, @Nullable final DebugWriter debugProtocol) throws IOException {
        this.guiStateManager = guiStateManager;
        this.debugProtocol = debugProtocol;
        selector = Selector.open();
    }
 
    public void start() {
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:start");
        }
        thread.start();
    }
 
    public void stop() throws InterruptedException {
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:stop");
        }
        thread.interrupt();
        try {
            selector.close();
        } catch (final IOException ex) {
            if (debugProtocol != null) {
                debugProtocol.debugProtocolWrite("close failed: "+ex.getMessage());
            }
        }
        thread.join();
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:stopped");
        }
    }
 
    public void addClientSocketListener(@NotNull final ClientSocketListener clientSocketListener) {
        clientSocketListeners.add(clientSocketListener);
    }
 
    public void removeClientSocketListener(@NotNull final ClientSocketListener clientSocketListener) {
        clientSocketListeners.remove(clientSocketListener);
    }
 
    public void connect(@NotNull final String host, final int port) {
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:connect "+host+":"+port);
        }
        synchronized (syncConnect) {
            if (this.host == null || this.port == 0 || !this.host.equals(host) || this.port != port) {
                reconnect = true;
                reconnectReason = "connect";
                reconnectIsError = false;
                this.host = host;
                this.port = port;
                selector.wakeup();
            }
        }
    }
 
    public void disconnect(@NotNull final String reason, final boolean isError) {
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:disconnect: "+reason+(isError ? " [unexpected]" : ""));
        }
        synchronized (syncConnect) {
            if (host != null || port != 0) {
                reconnect = true;
                reconnectReason = reason;
                reconnectIsError = isError;
                host = null;
                port = 0;
                selector.wakeup();
            }
        }
    }
 
    private void process() {
        while (!thread.isInterrupted()) {
            try {
                doReconnect();
                doConnect();
                updateWriteInterestOps();
                doTransceive();
            } catch (final EOFException ex) {
                final String tmp = ex.getMessage();
                final String message = tmp == null ? "EOF" : tmp;
                if (debugProtocol != null) {
                    debugProtocol.debugProtocolWrite("socket:exception "+message, ex);
                }
                processDisconnect(message, false);
            } catch (final IOException ex) {
                final String tmp = ex.getMessage();
                final String message = tmp == null ? "I/O error" : tmp;
                if (debugProtocol != null) {
                    debugProtocol.debugProtocolWrite("socket:exception "+message, ex);
                }
                processDisconnect(message, true);
            }
        }
    }
 
    private void doConnect() throws IOException {
        final boolean notifyConnected;
        synchronized (syncOutput) {
            if (isConnected || socketChannel == null) {
                notifyConnected = false;
            } else {
                isConnected = socketChannel.finishConnect();
                if (isConnected) {
                    interestOps = SelectionKey.OP_READ;
                    updateInterestOps();
                    notifyConnected = true;
                } else {
                    notifyConnected = false;
                }
            }
        }
        if (notifyConnected) {
            for (ClientSocketListener clientSocketListener : clientSocketListeners) {
                clientSocketListener.connected();
            }
        }
    }
 
    private void doReconnect() throws IOException {
        assert Thread.currentThread() == thread;
 
        final boolean doReconnect;
        final boolean doDisconnect;
        @Nullable final String disconnectReason;
        final boolean disconnectIsError;
        synchronized (syncConnect) {
            if (reconnect) {
                reconnect = false;
                if (host != null && port != 0) {
                    doReconnect = true;
                    doDisconnect = false;
                    disconnectReason = "reconnect to "+host+":"+port;
                    disconnectIsError = false;
                } else {
                    doReconnect = false;
                    doDisconnect = true;
                    disconnectReason = reconnectReason;
                    disconnectIsError = reconnectIsError;
                }
            } else {
                doReconnect = false;
                doDisconnect = false;
                disconnectReason = null;
                disconnectIsError = false;
            }
        }
        if (doReconnect) {
            assert disconnectReason != null;
            processDisconnect(disconnectReason, disconnectIsError);
            final String connectHost;
            final int connectPort;
            synchronized (syncConnect) {
                disconnectPending = true;
                connectHost = host;
                connectPort = port;
            }
            if (connectHost != null) {
                processConnect(connectHost, connectPort);
            }
        }
        if (doDisconnect) {
            processDisconnect(disconnectReason, disconnectIsError);
        }
    }
 
    private void doTransceive() throws IOException {
        selector.select();
        if (Thread.currentThread().isInterrupted()) {
            return;
        }
        final Collection<SelectionKey> selectedKeys = selector.selectedKeys();
        final boolean process;
        synchronized (syncOutput) {
            process = selectedKeys.remove(selectionKey) && isConnected;
        }
        if (process) {
            processRead();
            processWrite();
        }
        assert selectedKeys.isEmpty();
    }
 
    private void processConnect(@NotNull final String host, final int port) throws IOException {
        assert Thread.currentThread() == thread;
 
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:connecting to "+host+":"+port);
        }
        for (ClientSocketListener clientSocketListener : clientSocketListeners) {
            clientSocketListener.connecting();
        }
 
        final SocketAddress socketAddress = new InetSocketAddress(host, port);
        synchronized (syncOutput) {
            ((Buffer)outputBuffer).clear();
            ((Buffer)inputBuffer).clear();
            selectionKey = null;
            try {
                socketChannel = SocketChannel.open();
                selectableChannel = socketChannel.configureBlocking(false);
                try {
                    isConnected = socketChannel.connect(socketAddress);
                } catch (final UnresolvedAddressException ex) {
                    throw new IOException("Cannot resolve address: "+socketAddress, ex);
                } catch (final IllegalArgumentException ex) {
                    throw new IOException(ex.getMessage(), ex);
                }
                try {
                    socketChannel.socket().setTcpNoDelay(true);
                } catch (final SocketException ex) {
                    if (debugProtocol != null) {
                        debugProtocol.debugProtocolWrite("socket:cannot set TCP_NODELAY option: "+ex.getMessage());
                    }
                }
                interestOps = SelectionKey.OP_CONNECT;
                selectionKey = selectableChannel.register(selector, interestOps);
            } finally {
                if (selectionKey == null) {
                    socketChannel = null;
                    selectableChannel = null;
                    isConnected = false;
                    interestOps = 0;
                }
            }
        }
    }
 
    private void processDisconnect(@NotNull final String reason, final boolean isError) {
        assert Thread.currentThread() == thread;
 
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:disconnecting: "+reason+(isError ? " [unexpected]" : ""));
        }
        final boolean notifyListeners;
        synchronized (syncConnect) {
            notifyListeners = disconnectPending;
            disconnectPending = false;
        }
        if (notifyListeners) {
            guiStateManager.disconnecting(reason, isError);
        }
 
        try {
            synchronized (syncOutput) {
                if (selectionKey != null) {
                    selectionKey.cancel();
                    selectionKey = null;
                    ((Buffer)outputBuffer).clear();
 
                    try {
                        if (socketChannel != null) {
                            socketChannel.socket().shutdownOutput();
                        }
                    } catch (final IOException ignored) {
                        // ignore
                    }
                    try {
                        if (socketChannel != null) {
                            socketChannel.close();
                        }
                    } catch (final IOException ignored) {
                        // ignore
                    }
                    socketChannel = null;
                    selectableChannel = null;
                    ((Buffer)inputBuffer).clear();
                }
            }
        } finally {
            if (notifyListeners) {
                guiStateManager.disconnected();
                for (ClientSocketListener clientSocketListener : clientSocketListeners) {
                    clientSocketListener.disconnected(reason);
                }
            }
        }
    }
 
    private void processRead() throws IOException {
        synchronized (syncOutput) {
            if (socketChannel == null) {
                return;
            }
 
            if (socketChannel.read(inputBuffer) == -1) {
                throw new EOFException("EOF");
            }
        }
        ((Buffer)inputBuffer).flip();
        processReadCommand();
        inputBuffer.compact();
    }
 
    private void processReadCommand() {
        while (true) {
            if (inputLen == -1) {
                if (inputBuffer.remaining() < 2) {
                    break;
                }
 
                inputLen = (inputBuffer.get()&0xFF)*0x100+(inputBuffer.get()&0xFF);
            }
 
            if (inputBuffer.remaining() < inputLen) {
                break;
            }
 
            final int start = inputBuffer.position();
            final int end = start+inputLen;
            ((Buffer)inputBuffer).position(start+inputLen);
            inputLen = -1;
            final ByteBuffer packet = ByteBuffer.wrap(inputBuf, start, end-start);
            packet.order(ByteOrder.BIG_ENDIAN);
            try {
                for (ClientSocketListener clientSocketListener : clientSocketListeners) {
                    clientSocketListener.packetReceived(packet);
                }
            } catch (final UnknownCommandException ex) {
                disconnect(ex.getMessage(), true);
                break;
            }
        }
    }
 
    public void writePacket(final byte @NotNull [] buf, final int len, @NotNull final ClientSocketMonitorCommand monitor) {
        synchronized (syncOutput) {
            if (socketChannel == null) {
                return;
            }
 
            packetHeader[0] = (byte)(len/0x100);
            packetHeader[1] = (byte)len;
            try {
                try {
                    outputBuffer.put(packetHeader);
                    outputBuffer.put(buf, 0, len);
                } catch (final BufferOverflowException ex) {
                    throw new IOException("buffer overflow", ex);
                }
            } catch (final IOException ignored) {
                try {
                    socketChannel.close();
                } catch (final IOException ignore) {
                    // ignore
                }
                return;
            }
        }
 
        selector.wakeup();
        for (ClientSocketListener clientSocketListener : clientSocketListeners) {
            clientSocketListener.packetSent(monitor);
        }
    }
 
    private void processWrite() throws IOException {
        synchronized (syncOutput) {
            if (outputBuffer.remaining() <= 0) {
                return;
            }
 
            ((Buffer)outputBuffer).flip();
            try {
                if (socketChannel == null) {
                    ((Buffer)outputBuffer).position(outputBuffer.limit());
                } else {
                    socketChannel.write(outputBuffer);
                }
            } finally {
                outputBuffer.compact();
            }
        }
    }
 
    private void updateWriteInterestOps() {
        synchronized (syncOutput) {
            final int newInterestOps;
            //noinspection IfMayBeConditional
            if (outputBuffer.position() > 0) {
                newInterestOps = interestOps|SelectionKey.OP_WRITE;
            } else {
                newInterestOps = interestOps&~SelectionKey.OP_WRITE;
            }
            if (interestOps != newInterestOps) {
                interestOps = newInterestOps;
                updateInterestOps();
            }
        }
    }
 
    private void updateInterestOps() {
        if (debugProtocol != null) {
            debugProtocol.debugProtocolWrite("socket:set interest ops to "+interestOps);
        }
        assert Thread.holdsLock(syncOutput);
        if (selectionKey != null) {
            selectionKey.interestOps(interestOps);
        }
    }
 
}