Start work on a JRakLib client library.

Author: jython234

src/main/java/net/beaconpe/jraklib/client/ClientInstance.java

@@ -0,0 +1,62 @@
+/**
+ * JRakLib is not affiliated with Jenkins Software LLC or RakNet.
+ * This software is a port of RakLib https://github.com/PocketMine/RakLib.
+
+ * This file is part of JRakLib.
+ *
+ * JRakLib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * JRakLib 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with JRakLib.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package net.beaconpe.jraklib.client;
+
+import net.beaconpe.jraklib.protocol.EncapsulatedPacket;
+
+/**
+ * An interface for communication with the client implementation
+ * .
+ * @author jython234
+ */
+public interface ClientInstance {
+
+    /**
+     * Called when the connection is opened to the RakNet server.
+     * @param serverId The serverId of the RakNet server.
+     */
+    void connectionOpened(long serverId);
+
+    /**
+     * Called when the connection is closed.
+     * @param reason The reason for the closure.
+     */
+    void connectionClosed(String reason);
+
+    /**
+     * Called when an <code>EncapsulatedPacket</code> is received from the RakNet server.
+     * @param packet The packet received.
+     * @param flags Flags from the packet.
+     */
+    void handleEncapsulated(EncapsulatedPacket packet, int flags);
+
+    /**
+     * Called when an unrecognized packet is received from the server.
+     * @param payload Raw payload (in bytes) of the strange packet.
+     */
+    void handleRaw(byte[] payload);
+
+    /**
+     * Called when an internal option is updated. Current only supports "bandwith"
+     * @param option The option name.
+     * @param value The option value.
+     */
+    void handleOption(String option, String value);
+}

src/main/java/net/beaconpe/jraklib/client/JRakLibClient.java

@@ -0,0 +1,186 @@
+/**
+ * JRakLib is not affiliated with Jenkins Software LLC or RakNet.
+ * This software is a port of RakLib https://github.com/PocketMine/RakLib.
+
+ * This file is part of JRakLib.
+ *
+ * JRakLib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * JRakLib 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with JRakLib.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package net.beaconpe.jraklib.client;
+
+import net.beaconpe.jraklib.Logger;
+import net.beaconpe.jraklib.protocol.UNCONNECTED_PING;
+import net.beaconpe.jraklib.protocol.UNCONNECTED_PONG;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetSocketAddress;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Represents a JRakLib Client.
+ * @author jython234
+ */
+public class JRakLibClient extends Thread{
+    private static long startTime = -1;
+    protected InetSocketAddress serverEndpoint;
+
+    protected Logger logger;
+    protected boolean shutdown = false;
+
+    protected List<byte[]> externalQueue;
+    protected List<byte[]> internalQueue;
+
+    public JRakLibClient(Logger logger, String serverIP, int serverPort){
+        if(serverPort < 1 || serverPort > 65536){
+            throw new IllegalArgumentException("Invalid port range.");
+        }
+        this.logger = logger;
+        this.serverEndpoint = new InetSocketAddress(serverIP, serverPort);
+
+        externalQueue = new LinkedList<>();
+        internalQueue = new LinkedList<>();
+
+        start();
+    }
+
+    /**
+     * Pings a RakNet server at the specified <code>serverIP</code> and <code>serverPort</code>.
+     * @param logger Logger implementation.
+     * @param serverIP The server's IP Address.
+     * @param serverPort The server's port.
+     * @param tries Amount of packets sent with no response before giving up. (tries)
+     * @param delay Delay between packets sent with no response. (In milliseconds)
+     * @throws IOException If there is a problem while reading/sending.
+     * @return The ping response
+     */
+    public static PingResponse pingServer(Logger logger, String serverIP, int serverPort, int tries, int delay) throws IOException {
+        if(startTime == -1){
+            startTime = System.currentTimeMillis();
+        }
+        UDPClientSocket socket = new UDPClientSocket(logger);
+        for(int i = 0; i < tries; i++){
+            UNCONNECTED_PING ping = new UNCONNECTED_PING();
+            ping.pingId = System.currentTimeMillis() - startTime; //Amount since start.
+            ping.encode();
+            socket.writePacket(ping.buffer, new InetSocketAddress(serverIP, serverPort));
+
+            DatagramPacket pkt = socket.readPacketBlocking(delay);
+            if(pkt != null && pkt.getData()[0] == UNCONNECTED_PONG.ID){
+                UNCONNECTED_PONG pong = new UNCONNECTED_PONG();
+                pong.buffer = pkt.getData();
+                pong.decode();
+                return new PingResponse(pong.serverID, pong.pingID, pong.serverName);
+            }
+        }
+        return null;
+    }
+
+    public boolean isShutdown(){
+        return shutdown == true;
+    }
+
+    public void shutdown(){
+        shutdown = true;
+    }
+
+    public int getServerPort(){
+        return serverEndpoint.getPort();
+    }
+
+    public String getServerIP(){
+        return serverEndpoint.getHostString();
+    }
+
+    public Logger getLogger(){
+        return logger;
+    }
+
+    public List<byte[]> getExternalQueue(){
+        return externalQueue;
+    }
+
+    public List<byte[]> getInternalQueue(){
+        return internalQueue;
+    }
+
+    public void pushMainToThreadPacket(byte[] bytes){
+        internalQueue.add(0, bytes);
+    }
+
+    public byte[] readMainToThreadPacket(){
+        if(!internalQueue.isEmpty()) {
+            byte[] data = internalQueue.get(internalQueue.size() - 1);
+            internalQueue.remove(data);
+            return data;
+        }
+        return null;
+    }
+
+    public void pushThreadToMainPacket(byte[] bytes){
+        externalQueue.add(0, bytes);
+    }
+
+    public byte[] readThreadToMainPacket(){
+        if(!externalQueue.isEmpty()) {
+            byte[] data = externalQueue.get(externalQueue.size() - 1);
+            externalQueue.remove(data);
+            return data;
+        }
+        return null;
+    }
+
+    private class ShutdownHandler extends Thread {
+        @Override
+        public void run() {
+            if (shutdown != true) {
+                logger.emergency("[JRakLib Thread #" + getId() + "] JRakLib crashed!");
+            }
+        }
+    }
+
+    /**
+     * Represents a PingResponse from a server.
+     */
+    public static class PingResponse {
+        /**
+         * The PingId from the packet. The original amount sent to the server was the time sent start. (in milliseconds)
+         * <br>
+         * You can find more information here: http://wiki.vg/Pocket_Minecraft_Protocol#ID_CONNECTED_PING_OPEN_CONNECTIONS_.280x01.29
+         */
+        public final long pingId;
+        /**
+         * The serverId from the packet. This is the server's unique identifier generated at startup. (The value changes each runtime, and could be modified in transport)
+         */
+        public final long serverId;
+        /**
+         * The server's name or MOTD.
+         */
+        public final String name;
+
+        public PingResponse(long serverId, long pingId, String name){
+            this.pingId = pingId;
+            this.serverId = serverId;
+            this.name = name;
+        }
+    }
+
+    @Override
+    public void run(){
+        setName("JRakLib Client Thread #"+getId());
+        Runtime.getRuntime().addShutdownHook(new ShutdownHandler());
+        UDPClientSocket socket = new UDPClientSocket(logger);
+    }
+}