TestCrossfireServer.java

Go to the documentation of this file.

package com.realtime.crossfire.jxclient.server.crossfire;
 
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.Semaphore;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;
 
public class TestCrossfireServer {
 
    @NotNull
    private final Charset charset = StandardCharsets.ISO_8859_1;
 
    @NotNull
    private final Semaphore sem = new Semaphore(0);
 
    @NotNull
    @SuppressWarnings({"resource", "IOResourceOpenedButNotSafelyClosed", "SocketOpenedButNotSafelyClosed"})
    private final ServerSocket server = new ServerSocket(0);
 
    @NotNull
    private final Thread thread = new Thread(this::run);
 
    @NotNull
    private final Object sync = new Object();
 
    @Nullable
    private Socket client;
 
    public TestCrossfireServer() throws IOException {
    }
 
    public void start() {
        thread.start();
    }
 
    public void stop() throws InterruptedException, IOException {
        thread.interrupt();
        synchronized (sync) {
            server.close();
            if (client != null) {
                client.close();
            }
        }
        thread.join();
    }
 
    public int getLocalPort() {
        return server.getLocalPort();
    }
 
    public void waitForCharacterLogin() throws InterruptedException {
        sem.acquire();
    }
 
    private void run() {
        try {
            final Socket tmp = acceptClient(server);
            synchronized (sync) {
                client = tmp;
            }
            try {
                final InputStream in = getInputStream(tmp);
                while (true) {
                    final byte[] data = readPacket(in);
                    if (data == null) {
                        break;
                    }
                    int paramsIndex;
                    for (paramsIndex = 0; paramsIndex < data.length; paramsIndex++) {
                        if (data[paramsIndex] == (byte)' ') {
                            break;
                        }
                    }
                    final String cmd = new String(data, 0, paramsIndex, charset);
                    if (paramsIndex < data.length && data[paramsIndex] == (byte)' ') {
                        paramsIndex++;
                    }
                    switch (cmd) {
                    case "version":
                        writeString("version 1 1 info");
                        break;
 
                    case "setup":
                        processSetup(new String(data, paramsIndex, data.length-paramsIndex, charset));
                        break;
 
                    case "requestinfo":
                        processRequestinfo(new String(data, paramsIndex, data.length-paramsIndex, charset));
                        break;
 
                    case "toggleextendedtext":
                        // ignore
                        break;
 
                    case "addme":
                        processAddme();
                        break;
 
                    default:
                        Assert.fail("received unexpected command: "+cmd);
                        break;
                    }
                }
            } finally {
                synchronized (sync) {
                    client = null;
                }
                //noinspection ThrowFromFinallyBlock
                tmp.close();
            }
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
    }
 
    private static byte @Nullable [] readPacket(@NotNull final InputStream in) throws EOFException {
        final int tmp;
        try {
            tmp = readByte(in);
        } catch (final EOFException ignored) {
            return null;
        }
        final int packetLen = tmp*0x100+readByte(in);
        final byte[] data = new byte[packetLen];
        try {
            int pos = 0;
            while (pos < data.length) {
                final int len = in.read(data, pos, data.length-pos);
                if (len == -1) {
                    throw new EOFException("unexpected end of file reached");
                }
                pos += len;
            }
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        return data;
    }
 
    private void processSetup(@NotNull final String params) throws IOException {
        final String[] params2 = params.split(" ", -1);
        Assert.assertEquals(0, params2.length%2);
        final StringBuilder sb = new StringBuilder("setup");
        for (int i = 0; i < params2.length; i += 2) {
            final String key = params2[i];
            final String value = params2[i+1];
            if (key.equals("map2cmd") || key.equals("newmapcmd") || key.equals("facecache") || key.equals("extendedTextInfos") || key.equals("itemcmd") || key.equals("spellmon") || key.equals("tick") || key.equals("num_look_objects") || key.equals("mapsize")) {
                sb.append(" ").append(key).append(" ").append(value);
            } else {
                sb.append(" ").append(key).append(" FALSE");
            }
        }
        writeString(sb.toString());
    }
 
    private void processRequestinfo(@NotNull final String params) throws IOException {
        switch (params) {
        case "exp_table":
            writeBytes("replyinfo exp_table \0\1".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "skill_info 1":
            writeBytes("replyinfo skill_info ".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "skill_extra 1":
            writeBytes("replyinfo skill_extra ".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "knowledge_info":
            writeBytes("replyinfo knowledge_info ".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "image_info":
            writeBytes("replyinfo image_info 0\n0\n".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "startingmap":
            writeBytes("replyinfo startingmap ".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "race_list":
            writeBytes("replyinfo race_list ".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "class_list":
            writeBytes("replyinfo class_list ".getBytes(StandardCharsets.US_ASCII));
            break;
 
        case "newcharinfo":
            writeBytes("replyinfo newcharinfo ".getBytes(StandardCharsets.US_ASCII));
            break;
 
        default:
            Assert.fail("requestinfo "+params+" not implemented");
            break;
        }
    }
 
    private void processAddme() throws IOException {
        writeString("query 0 What is your name?");
        writeString("addme_success");
        assert sem != null;
        sem.release();
    }
 
    private static int readByte(@NotNull final InputStream in) throws EOFException {
        final int ch;
        try {
            ch = in.read();
        } catch (final SocketException ex) {
            final String message = ex.getMessage();
            if (!message.equals("Socket closed")) {
                Assert.fail(message);
                throw new AssertionError(ex);
            }
            final EOFException ex2 = new EOFException("EOF");
            ex2.initCause(ex);
            throw ex2;
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        if (ch == -1) {
            throw new EOFException("EOF");
        }
        return ch;
    }
 
    public void writeString(@NotNull final String s) throws IOException {
        writeBytes(s.getBytes(charset));
    }
 
    public void writeBytes(final byte @NotNull [] b) throws IOException {
        final OutputStream out = getOutputStream();
        final int len = b.length;
        out.write(len/0x100);
        out.write(len);
        out.write(b);
    }
 
    @NotNull
    private static Socket acceptClient(@NotNull final ServerSocket server) {
        final Socket client;
        try {
            //noinspection SocketOpenedButNotSafelyClosed
            client = server.accept();
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        return client;
    }
 
    @NotNull
    private static InputStream getInputStream(@NotNull final Socket socket) {
        final InputStream in;
        try {
            in = socket.getInputStream();
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        return in;
    }
 
    @NotNull
    private OutputStream getOutputStream() {
        final Socket tmp;
        synchronized (sync) {
            tmp = client;
        }
        if (tmp == null) {
            Assert.fail("no client connection");
        }
 
        final OutputStream out;
        try {
            out = tmp.getOutputStream();
        } catch (final IOException ex) {
            Assert.fail(ex.getMessage());
            throw new AssertionError(ex);
        }
        return out;
    }
 
}