- Finished up with classic packets

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>github.openautonomousconnection</groupId>
     <artifactId>protocol</artifactId>
-    <version>1.0.3-SNAPSHOT</version>
+    <version>1.0.0-BETA.1</version>
     <organization>
         <name>Open Autonomous Connection</name>
         <url>https://open-autonomous-connection.org/</url>
@@ -87,7 +87,7 @@
         <dependency>
             <groupId>me.finn.unlegitlibrary</groupId>
             <artifactId>unlegitlibrary</artifactId>
-            <version>1.5.15</version>
+            <version>1.6.2</version>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>

src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java

@@ -1,17 +1,21 @@
 package github.openautonomousconnection.protocol;
 
-import github.openautonomousconnection.protocol.handle.ClassicHandlerServer;
+import github.openautonomousconnection.protocol.listeners.ClientListener;
+import github.openautonomousconnection.protocol.listeners.ServerListener;
+import github.openautonomousconnection.protocol.packets.OACPacket;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.ClassicHandlerClient;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.ClassicHandlerServer;
 import github.openautonomousconnection.protocol.packets.v1_0_0.classic.Classic_DomainPacket;
-import github.openautonomousconnection.protocol.packets.v1_0_0.classic.Classic_MessagePacket;
+import github.openautonomousconnection.protocol.side.client.ProtocolClient;
-import github.openautonomousconnection.protocol.packets.v1_0_0.classic.Classic_PingPacket;
+import github.openautonomousconnection.protocol.side.server.ProtocolServer;
-import github.openautonomousconnection.protocol.side.ProtocolClient;
-import github.openautonomousconnection.protocol.side.ProtocolServer;
 import lombok.Getter;
 import lombok.Setter;
 import me.finn.unlegitlibrary.utils.Logger;
 
 import java.io.File;
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
 
 public class ProtocolBridge {
 
@@ -32,11 +36,13 @@ public class ProtocolBridge {
 
     @Getter @Setter
     private ClassicHandlerServer classicHandlerServer;
+    @Getter @Setter
+    private ClassicHandlerClient classicHandlerClient;
 
     @Getter
     private static ProtocolBridge instance;
 
-    public ProtocolBridge(ProtocolServer protocolServer, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) {
+    public ProtocolBridge(ProtocolServer protocolServer, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) throws InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
         this.protocolServer = protocolServer;
         this.protocolSettings = protocolSettings;
         this.protocolVersion = protocolVersion;
@@ -51,8 +57,10 @@ public class ProtocolBridge {
         }
 
         this.logger = tmpLogger;
+        protocolSettings.eventManager.registerListener(new ServerListener());
+        protocolSettings.eventManager.unregisterListener(new ClientListener());
 
-        if (!validateProtocolVersion()) {
+        if (!validateProtocolSide()) {
             this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!");
             System.exit(1);
         }
@@ -60,7 +68,7 @@ public class ProtocolBridge {
         instance = this;
     }
 
-    public ProtocolBridge(ProtocolClient protocolClient, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) {
+    public ProtocolBridge(ProtocolClient protocolClient, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) throws InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
         this.protocolClient = protocolClient;
         this.protocolSettings = protocolSettings;
         this.protocolVersion = protocolVersion;
@@ -75,21 +83,31 @@ public class ProtocolBridge {
         }
 
         this.logger = tmpLogger;
+        protocolSettings.eventManager.registerListener(new ClientListener());
+        protocolSettings.eventManager.unregisterListener(new ServerListener());
 
-        if (!validateProtocolVersion()) {
+        if (!validateProtocolSide()) {
             this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!");
             System.exit(1);
         }
 
         if (isClassicSupported()) {
-            protocolSettings.packetHandler.registerPacket(new Classic_DomainPacket());
+            Classic_DomainPacket cDomainPacket = new Classic_DomainPacket();
-            protocolSettings.packetHandler.registerPacket(new Classic_MessagePacket());
+            Classic_DomainPacket cMessagePacket = new Classic_DomainPacket();
-            protocolSettings.packetHandler.registerPacket(new Classic_PingPacket());
+            Classic_DomainPacket cPingPacket = new Classic_DomainPacket();
+
+            if (isPacketSupported(cDomainPacket)) protocolSettings.packetHandler.registerPacket(cDomainPacket);
+            if (isPacketSupported(cMessagePacket)) protocolSettings.packetHandler.registerPacket(cMessagePacket);
+            if (isPacketSupported(cPingPacket)) protocolSettings.packetHandler.registerPacket(cPingPacket);
         }
 
         instance = this;
     }
 
+    public boolean isPacketSupported(OACPacket packet) {
+        return isVersionSupported(packet.getProtocolVersion());
+    }
+
     public boolean isClassicSupported() {
         boolean yes = false;
         for (ProtocolVersion compatibleVersion : protocolVersion.getCompatibleVersions()) {
@@ -108,12 +126,12 @@ public class ProtocolBridge {
         return protocolClient != null;
     }
 
-    private boolean validateProtocolVersion() {
+    private boolean validateProtocolSide() {
         return (isRunningAsServer() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.CLIENT) ||
                 (isRunningAsClient() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.SERVER);
     }
 
-    public boolean validateProtocolVersion(ProtocolVersion targetVersion) {
+    public boolean isVersionSupported(ProtocolVersion targetVersion) {
         return protocolVersion == targetVersion || protocolVersion.getCompatibleVersions().contains(targetVersion);
     }
 }

src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java

@@ -1,4 +0,0 @@
-package github.openautonomousconnection.protocol.classic;
-
-public class ClassicConverter {
-}

src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java

@@ -1,77 +0,0 @@
-package github.openautonomousconnection.protocol.classic;
-
-import me.finn.unlegitlibrary.string.StringUtils;
-
-import java.io.Serializable;
-
-public class Classic_Domain implements Serializable {
-    public final String name;
-    public final String topLevelDomain;
-    private final String destination;
-    private final String path;
-
-    public Classic_Domain(String name, String topLevelDomain, String destination, String path) {
-        if (path == null) path = "";
-
-        this.name = name;
-        this.topLevelDomain = topLevelDomain;
-        this.destination = destination;
-        this.path = path;
-    }
-
-    public final String realDestination() {
-        String tmpDestination = destination.endsWith("/") ? destination : destination + "/";
-        String tmpPath = getPath();
-
-        if (tmpPath == null) tmpPath = "";
-        if (tmpPath.startsWith("/")) tmpPath = tmpPath.substring("/".length());
-        if (tmpPath.endsWith("/")) tmpPath = tmpPath.substring(0, tmpPath.length() - "/".length());
-
-        return tmpDestination + tmpPath;
-    }
-
-    public final String getPath() {
-        if (path.endsWith("/")) return path.substring(0, path.length() - "/".length());
-        if (path.startsWith("/")) return path.substring("/".length());
-        return path;
-    }
-
-    public final String parsedDestination() {
-        if (destination.toLowerCase().startsWith("https://github.com/")) {
-            String base = "https://raw.githubusercontent.com/";
-            String username = Classic_DomainUtils.getPath(destination).split("/")[0];
-            String site = Classic_DomainUtils.getPath(destination).split("/")[1];
-
-            String tmpPath = getPath();
-            if (tmpPath == null || StringUtils.isEmptyString(tmpPath)) tmpPath = "index.html";
-            if (tmpPath.startsWith("/")) tmpPath = tmpPath.substring("/".length());
-            if (tmpPath.endsWith("/")) tmpPath = tmpPath.substring(0, tmpPath.length() - "/".length());
-
-            base = base + username + "/" + site + "/main/" + tmpPath;
-            return base;
-        }
-
-        return realDestination();
-    }
-
-    @Override
-    protected final Object clone() throws CloneNotSupportedException {
-        return new Classic_Domain(name, topLevelDomain, destination, path);
-    }
-
-    @Override
-    public final boolean equals(Object obj) {
-        if (!(obj instanceof Classic_Domain other)) return false;
-        return other.name.equalsIgnoreCase(name) && other.topLevelDomain.equalsIgnoreCase(topLevelDomain);
-    }
-
-    @Override
-    public final String toString() {
-        return "{parsed='" + parsedDestination() + "';real='" + realDestination() + "'}";
-    }
-
-    @Override
-    public final int hashCode() {
-        return super.hashCode();
-    }
-}

src/main/java/github/openautonomousconnection/protocol/listeners/ClientListener.java

@@ -0,0 +1,29 @@
+package github.openautonomousconnection.protocol.listeners;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.packets.v1_0_0.beta.AuthPacket;
+import me.finn.unlegitlibrary.event.EventListener;
+import me.finn.unlegitlibrary.event.Listener;
+import me.finn.unlegitlibrary.network.system.client.events.ClientConnectedEvent;
+import me.finn.unlegitlibrary.network.system.client.events.ClientDisconnectedEvent;
+
+import java.io.IOException;
+
+public class ClientListener extends EventListener {
+
+    @Listener
+    public void onConnect(ClientConnectedEvent event) {
+        try {
+            event.client.sendPacket(new AuthPacket());
+        } catch (IOException | ClassNotFoundException exception) {
+            ProtocolBridge.getInstance().getLogger().exception("Failed to send auth packet", exception);
+            event.client.disconnect();
+        }
+    }
+
+    @Listener
+    public void onDisconnect(ClientDisconnectedEvent event) {
+        ProtocolBridge.getInstance().getProtocolClient().onDisconnect(event);
+    }
+
+}

src/main/java/github/openautonomousconnection/protocol/listeners/ServerListener.java

@@ -0,0 +1,24 @@
+package github.openautonomousconnection.protocol.listeners;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.side.server.ConnectedProtocolClient;
+import me.finn.unlegitlibrary.event.EventListener;
+import me.finn.unlegitlibrary.event.Listener;
+import me.finn.unlegitlibrary.network.system.server.events.ConnectionHandlerConnectedEvent;
+import me.finn.unlegitlibrary.network.system.server.events.ConnectionHandlerDisconnectedEvent;
+
+import java.util.ArrayList;
+
+public class ServerListener extends EventListener {
+
+    @Listener
+    public void onConnect(ConnectionHandlerConnectedEvent event) {
+        ProtocolBridge.getInstance().getProtocolServer().getClients().add(new ConnectedProtocolClient(event.connectionHandler));
+    }
+
+    @Listener
+    public void onDisconnect(ConnectionHandlerDisconnectedEvent event) {
+        ProtocolBridge.getInstance().getProtocolServer().getClients().removeIf(client -> client.getConnectionHandler().getClientID() == -1);
+    }
+
+}

src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java

@@ -1,16 +1,15 @@
 package github.openautonomousconnection.protocol.packets;
 
-import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
-import github.openautonomousconnection.protocol.ProtocolVersion;
 import lombok.Getter;
 import me.finn.unlegitlibrary.network.system.packets.Packet;
 
 public abstract class OACPacket extends Packet {
     @Getter
-    private final ProtocolVersion.ProtocolType packetType;
+    private final ProtocolVersion protocolVersion;
 
-    public OACPacket(int id, ProtocolVersion.ProtocolType packetType) {
+    public OACPacket(int id, ProtocolVersion protocolVersion) {
         super(id);
-        this.packetType = packetType;
+        this.protocolVersion = protocolVersion;
     }
 }

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/AuthPacket.java

@@ -0,0 +1,54 @@
+package github.openautonomousconnection.protocol.packets.v1_0_0.beta;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.packets.OACPacket;
+import github.openautonomousconnection.protocol.side.client.events.ConnectedToProtocolServer;
+import github.openautonomousconnection.protocol.side.server.ConnectedProtocolClient;
+import github.openautonomousconnection.protocol.side.server.events.ProtocolClientConnected;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
+import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
+import me.finn.unlegitlibrary.network.system.server.ConnectionHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public class AuthPacket extends OACPacket {
+
+    public AuthPacket() {
+        super(4, ProtocolVersion.PV_1_0_0_BETA);
+    }
+
+    @Override
+    public void write(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) objectOutputStream.writeObject(ProtocolBridge.getInstance().getProtocolVersion());
+        else {
+            objectOutputStream.writeInt(ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID());
+            objectOutputStream.writeObject(ProtocolBridge.getInstance().getProtocolVersion());
+        }
+    }
+
+    @Override
+    public void read(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            int clientID = objectInputStream.readInt();
+            ProtocolVersion clientVersion = (ProtocolVersion) objectInputStream.readObject();
+            ConnectionHandler connectionHandler = ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID);
+
+            if (!ProtocolBridge.getInstance().isVersionSupported(clientVersion)) connectionHandler.disconnect();
+            else {
+                ConnectedProtocolClient client = ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID);
+                client.setClientVersion(clientVersion);
+                ProtocolBridge.getInstance().getProtocolSettings().eventManager.executeEvent(new ProtocolClientConnected(client));
+            }
+        } else {
+            ProtocolVersion serverVersion = (ProtocolVersion) objectInputStream.readObject();
+
+            if (!ProtocolBridge.getInstance().isVersionSupported(serverVersion)) ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().disconnect();
+            else {
+                ProtocolBridge.getInstance().getProtocolClient().setServerVersion(serverVersion);
+                ProtocolBridge.getInstance().getProtocolSettings().eventManager.executeEvent(new ConnectedToProtocolServer());
+            }
+        }
+    }
+}

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java

@@ -0,0 +1,46 @@
+package github.openautonomousconnection.protocol.packets.v1_0_0.beta;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.packets.OACPacket;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
+import me.finn.unlegitlibrary.network.system.packets.Packet;
+import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public class UnsupportedClassicPacket extends OACPacket {
+    private Class<? extends OACPacket> unsupportedClassicPacket;
+    private Object[] content;
+
+    public UnsupportedClassicPacket(Class<? extends OACPacket> unsupportedClassicPacket, Object[] content) {
+        this();
+        this.unsupportedClassicPacket = unsupportedClassicPacket;
+        this.content = content;
+    }
+
+    public UnsupportedClassicPacket() {
+        super(5, ProtocolVersion.PV_1_0_0_BETA);
+    }
+
+    @Override
+    public void write(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        objectOutputStream.writeUTF(unsupportedClassicPacket.getName());
+        objectOutputStream.writeInt(content.length);
+        for (Object o : content) objectOutputStream.writeObject(o);
+    }
+
+    @Override
+    public void read(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        String className = objectInputStream.readUTF();
+        int size = objectInputStream.readInt();
+        content = new Object[size];
+
+        for (int i = 0; i < size; i++) {
+            content[i] = objectInputStream.readObject();
+        }
+
+        ProtocolBridge.getInstance().getClassicHandlerClient().unsupportedClassicPacket(className, content);
+    }
+}

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_DomainPacket.java

@@ -1,11 +1,12 @@
 package github.openautonomousconnection.protocol.packets.v1_0_0.classic;
 
 import github.openautonomousconnection.protocol.ProtocolBridge;
-import github.openautonomousconnection.protocol.ProtocolVersion;
+import github.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket;
-import github.openautonomousconnection.protocol.classic.Classic_Domain;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
-import github.openautonomousconnection.protocol.classic.Classic_DomainPacketReceivedEvent;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_Domain;
-import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_DomainPacketReceivedEvent;
-import github.openautonomousconnection.protocol.classic.Classic_RequestDomain;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_ProtocolVersion;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_RequestDomain;
 import github.openautonomousconnection.protocol.packets.OACPacket;
 import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
 
@@ -23,12 +24,13 @@ public class Classic_DomainPacket extends OACPacket {
     public Classic_DomainPacket(int toClient, Classic_RequestDomain requestDomain, Classic_Domain domain) {
         this();
         this.clientID = toClient;
+
         this.requestDomain = requestDomain;
         this.domain = domain;
     }
 
     public Classic_DomainPacket() {
-        super(2, ProtocolVersion.ProtocolType.CLASSIC);
+        super(2, ProtocolVersion.PV_1_0_0_CLASSIC);
     }
 
     @Override
@@ -53,6 +55,8 @@ public class Classic_DomainPacket extends OACPacket {
         }
 
         ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getEventManager().executeEvent(new Classic_DomainPacketReceivedEvent(protocolVersion, domain, requestDomain, clientID));
-        ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new Classic_DomainPacket(clientID, requestDomain, domain));
+
+        if (ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID).clientSupportClassic()) ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new Classic_DomainPacket(clientID, requestDomain, domain));
+        else ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new UnsupportedClassicPacket(Classic_PingPacket.class, new Object[] {clientID, requestDomain, domain}));
     }
 }

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java

@@ -1,8 +1,8 @@
 package github.openautonomousconnection.protocol.packets.v1_0_0.classic;
 
 import github.openautonomousconnection.protocol.ProtocolBridge;
-import github.openautonomousconnection.protocol.ProtocolVersion;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
-import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_ProtocolVersion;
 import github.openautonomousconnection.protocol.packets.OACPacket;
 import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
 
@@ -22,7 +22,7 @@ public class Classic_MessagePacket extends OACPacket {
     }
 
     public Classic_MessagePacket() {
-        super(3, ProtocolVersion.ProtocolType.CLASSIC);
+        super(3, ProtocolVersion.PV_1_0_0_CLASSIC);
     }
 
     @Override
@@ -39,6 +39,6 @@ public class Classic_MessagePacket extends OACPacket {
         String message = objectInputStream.readUTF();
         Classic_ProtocolVersion protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
 
-        ProtocolBridge.getInstance().getClassicHandlerServer().handleMessage(ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID), message);
+        ProtocolBridge.getInstance().getClassicHandlerServer().handleMessage(ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID), message, protocolVersion);
     }
 }

src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_PingPacket.java

@@ -1,11 +1,12 @@
 package github.openautonomousconnection.protocol.packets.v1_0_0.classic;
 
 import github.openautonomousconnection.protocol.ProtocolBridge;
-import github.openautonomousconnection.protocol.ProtocolVersion;
+import github.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket;
-import github.openautonomousconnection.protocol.classic.Classic_Domain;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
-import github.openautonomousconnection.protocol.classic.Classic_PingPacketReceivedEvent;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_Domain;
-import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_PingPacketReceivedEvent;
-import github.openautonomousconnection.protocol.classic.Classic_RequestDomain;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_ProtocolVersion;
+import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_RequestDomain;
 import github.openautonomousconnection.protocol.packets.OACPacket;
 import me.finn.unlegitlibrary.network.system.packets.PacketHandler;
 
@@ -31,7 +32,7 @@ public class Classic_PingPacket extends OACPacket {
     }
 
     public Classic_PingPacket() {
-        super(1, ProtocolVersion.ProtocolType.CLASSIC);
+        super(1, ProtocolVersion.PV_1_0_0_CLASSIC);
     }
 
     @Override
@@ -57,6 +58,7 @@ public class Classic_PingPacket extends OACPacket {
 
         reachable = domain != null;
         ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getEventManager().executeEvent(new Classic_PingPacketReceivedEvent(protocolVersion, domain, requestDomain, reachable, clientID));
-        ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new Classic_PingPacket(requestDomain, domain, reachable));
+        if (ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID).clientSupportClassic()) ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new Classic_PingPacket(requestDomain, domain, reachable));
+        else ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new UnsupportedClassicPacket(Classic_PingPacket.class, new Object[] {requestDomain, domain, reachable}));
     }
 }

src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java

@@ -1,4 +0,0 @@
-package github.openautonomousconnection.protocol.side;
-
-public class ProtocolClient {
-}

src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java

@@ -1,23 +0,0 @@
-package github.openautonomousconnection.protocol.side;
-
-import github.openautonomousconnection.protocol.ProtocolBridge;
-import lombok.Getter;
-import me.finn.unlegitlibrary.network.system.server.NetworkServer;
-
-public abstract class ProtocolServer {
-    @Getter
-    private final ProtocolBridge protocolBridge;
-
-    @Getter
-    private NetworkServer networkServer;
-
-    public ProtocolServer(ProtocolBridge protocolBridge) {
-        this.protocolBridge = protocolBridge;
-
-        this.networkServer = new NetworkServer.ServerBuilder().
-                setEventManager(protocolBridge.getProtocolSettings().eventManager).
-                setPacketHandler(protocolBridge.getProtocolSettings().packetHandler).
-                setPort(protocolBridge.getProtocolSettings().port).
-                build();
-    }
-}

src/main/java/github/openautonomousconnection/protocol/side/client/ProtocolClient.java

@@ -0,0 +1,89 @@
+package github.openautonomousconnection.protocol.side.client;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import github.openautonomousconnection.protocol.packets.OACPacket;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
+import lombok.Getter;
+import me.finn.unlegitlibrary.network.system.client.NetworkClient;
+import me.finn.unlegitlibrary.network.system.client.events.ClientDisconnectedEvent;
+import me.finn.unlegitlibrary.network.system.server.NetworkServer;
+import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider;
+
+import java.io.File;
+
+public class ProtocolClient extends DefaultMethodsOverrider {
+    private ProtocolVersion serverVersion = null;
+
+    @Getter
+    private final NetworkClient networkClient;
+
+    public ProtocolVersion getServerVersion() {
+        return serverVersion == null ? ProtocolVersion.PV_1_0_0_CLASSIC : serverVersion;
+    }
+
+    public void setServerVersion(ProtocolVersion serverVersion) {
+        if (serverVersion == null) this.serverVersion = serverVersion;
+    }
+
+    public final void onDisconnect(ClientDisconnectedEvent event) {
+        serverVersion = null;
+    }
+
+    public boolean isStableServer() {
+        return !isBetaServer() && !isClassicServer();
+    }
+
+    public boolean serverSupportStable() {
+        boolean yes = false;
+        for (ProtocolVersion compatibleVersion : getServerVersion().getCompatibleVersions()) {
+            yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.STABLE;
+            if (yes) break;
+        }
+
+        return isStableServer() || yes;
+    }
+
+    public boolean isBetaServer() {
+        return getServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.BETA;
+    }
+
+    public boolean serverSupportBeta() {
+        boolean yes = false;
+        for (ProtocolVersion compatibleVersion : getServerVersion().getCompatibleVersions()) {
+            yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.BETA;
+            if (yes) break;
+        }
+
+        return isBetaServer() || yes;
+    }
+
+    public boolean isClassicServer() {
+        return getServerVersion().getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+    }
+
+    public boolean serverSupportClassic() {
+        boolean yes = false;
+        for (ProtocolVersion compatibleVersion : getServerVersion().getCompatibleVersions()) {
+            yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+            if (yes) break;
+        }
+
+        return isClassicServer() || yes;
+    }
+
+    public boolean isPacketSupported(OACPacket packet) {
+        return isVersionSupported(packet.getProtocolVersion());
+    }
+
+    public boolean isVersionSupported(ProtocolVersion targetVersion) {
+        return getServerVersion() == targetVersion || getServerVersion().getCompatibleVersions().contains(targetVersion);
+    }
+
+    public ProtocolClient(File caFolder, File certificatesClientFolder, File certificatesKeyFolder) {
+        networkClient = new NetworkClient.ClientBuilder().setLogger(ProtocolBridge.getInstance().getLogger()).
+                setHost(ProtocolBridge.getInstance().getProtocolSettings().host).setPort(ProtocolBridge.getInstance().getProtocolSettings().port).
+                setPacketHandler(ProtocolBridge.getInstance().getProtocolSettings().packetHandler).setEventManager(ProtocolBridge.getInstance().getProtocolSettings().eventManager).
+                setRootCAFolder(caFolder).setClientCertificatesFolder(certificatesClientFolder, certificatesKeyFolder).
+                build();
+    }
+}

src/main/java/github/openautonomousconnection/protocol/side/client/events/ConnectedToProtocolServer.java

@@ -0,0 +1,6 @@
+package github.openautonomousconnection.protocol.side.client.events;
+
+import me.finn.unlegitlibrary.event.impl.Event;
+
+public class ConnectedToProtocolServer extends Event {
+}

src/main/java/github/openautonomousconnection/protocol/side/server/ConnectedProtocolClient.java

@@ -0,0 +1,76 @@
+package github.openautonomousconnection.protocol.side.server;
+
+import github.openautonomousconnection.protocol.packets.OACPacket;
+import github.openautonomousconnection.protocol.versions.ProtocolVersion;
+import lombok.Getter;
+import me.finn.unlegitlibrary.network.system.server.ConnectionHandler;
+
+public class ConnectedProtocolClient {
+
+    @Getter
+    private final ConnectionHandler connectionHandler;
+
+    private ProtocolVersion clientVersion = null;
+
+    public ProtocolVersion getClientVersion() {
+        return clientVersion == null ? ProtocolVersion.PV_1_0_0_CLASSIC : clientVersion;
+    }
+
+    public void setClientVersion(ProtocolVersion clientVersion) {
+        if (clientVersion == null) this.clientVersion = clientVersion;
+    }
+
+    public ConnectedProtocolClient(ConnectionHandler connectionHandler) {
+        this.connectionHandler = connectionHandler;
+    }
+
+    public boolean isStableClient() {
+        return !isBetaClient() && !isClassicClient();
+    }
+
+    public boolean clientSupportStable() {
+        boolean yes = false;
+        for (ProtocolVersion compatibleVersion : getClientVersion().getCompatibleVersions()) {
+            yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.STABLE;
+            if (yes) break;
+        }
+
+        return isStableClient() || yes;
+    }
+
+    public boolean isBetaClient() {
+        return getClientVersion().getProtocolType() == ProtocolVersion.ProtocolType.BETA;
+    }
+
+    public boolean clientSupportBeta() {
+        boolean yes = false;
+        for (ProtocolVersion compatibleVersion : getClientVersion().getCompatibleVersions()) {
+            yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.BETA;
+            if (yes) break;
+        }
+
+        return isBetaClient() || yes;
+    }
+
+    public boolean isClassicClient() {
+        return getClientVersion().getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+    }
+
+    public boolean clientSupportClassic() {
+        boolean yes = false;
+        for (ProtocolVersion compatibleVersion : getClientVersion().getCompatibleVersions()) {
+            yes = compatibleVersion.getProtocolType() == ProtocolVersion.ProtocolType.CLASSIC;
+            if (yes) break;
+        }
+
+        return isClassicClient() || yes;
+    }
+
+    public boolean isPacketSupported(OACPacket packet) {
+        return isVersionSupported(packet.getProtocolVersion());
+    }
+
+    public boolean isVersionSupported(ProtocolVersion targetVersion) {
+        return getClientVersion() == targetVersion || getClientVersion().getCompatibleVersions().contains(targetVersion);
+    }
+}

src/main/java/github/openautonomousconnection/protocol/side/server/ProtocolServer.java

@@ -0,0 +1,34 @@
+package github.openautonomousconnection.protocol.side.server;
+
+import github.openautonomousconnection.protocol.ProtocolBridge;
+import lombok.Getter;
+import me.finn.unlegitlibrary.network.system.server.NetworkServer;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class ProtocolServer {
+    @Getter
+    private final NetworkServer networkServer;
+
+    @Getter
+    private List<ConnectedProtocolClient> clients;
+
+    public ConnectedProtocolClient getClientByID(int clientID) {
+        for (ConnectedProtocolClient client : clients) if (client.getConnectionHandler().getClientID() == clientID) return client;
+        return null;
+    }
+
+    public ProtocolServer(File caFolder, File certFile, File keyFile) {
+        ProtocolBridge protocolBridge = ProtocolBridge.getInstance();
+        this.clients = new ArrayList<>();
+
+        this.networkServer = new NetworkServer.ServerBuilder().setLogger(protocolBridge.getLogger()).
+                setEventManager(protocolBridge.getProtocolSettings().eventManager).
+                setPacketHandler(protocolBridge.getProtocolSettings().packetHandler).
+                setPort(protocolBridge.getProtocolSettings().port).
+                setRequireClientCertificate(false).setRootCAFolder(caFolder).setServerCertificate(certFile, keyFile).
+                build();
+    }
+}

src/main/java/github/openautonomousconnection/protocol/side/server/events/ProtocolClientConnected.java

@@ -0,0 +1,15 @@
+package github.openautonomousconnection.protocol.side.server.events;
+
+import github.openautonomousconnection.protocol.side.server.ConnectedProtocolClient;
+import lombok.Getter;
+import me.finn.unlegitlibrary.event.impl.Event;
+
+public class ProtocolClientConnected extends Event {
+
+    @Getter
+    private final ConnectedProtocolClient protocolClient;
+
+    public ProtocolClientConnected(ConnectedProtocolClient protocolClient) {
+        this.protocolClient = protocolClient;
+    }
+}

src/main/java/github/openautonomousconnection/protocol/versions/ProtocolVersion.java

@@ -1,4 +1,4 @@
-package github.openautonomousconnection.protocol;
+package github.openautonomousconnection.protocol.versions;
 
 import lombok.Getter;
 
@@ -25,7 +25,8 @@ public enum ProtocolVersion implements Serializable {
         this.version = version;
         this.protocolType = protocolType;
         this.protocolSide = protocolSide;
-        this.compatibleVersions = new ArrayList<>(Arrays.stream(new ProtocolVersion[] { this }).toList());
+        this.compatibleVersions = new ArrayList<>(Arrays.stream(compatibleVersions).toList());
+        if (!this.compatibleVersions.contains(this)) this.compatibleVersions.add(this);
     }
 
     @Override
@@ -41,10 +42,9 @@ public enum ProtocolVersion implements Serializable {
         return version + "-" + protocolType.toString();
     }
 
-    public enum ProtocolType {
+    public enum ProtocolType implements Serializable {
         CLASSIC, // -> See "_old" Projects on GitHub Organisation https://github.com/Open-Autonomous-Connection/
         BETA,
-        ALPHA,
         STABLE
 
         ;
@@ -55,7 +55,7 @@ public enum ProtocolVersion implements Serializable {
         }
     }
 
-    public enum ProtocolSide {
+    public enum ProtocolSide implements Serializable {
         CLIENT, // Protocol version can only used on Client
         SERVER, // Protocol version can only used on Server
         BOTH // Protocol version can only used on Server and Client

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/Domain.java

@@ -0,0 +1,63 @@
+package github.openautonomousconnection.protocol.versions.v1_0_0.beta;
+
+import lombok.Getter;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.List;
+
+public class Domain implements Serializable {
+    @Getter
+    private final String subname;
+    @Getter
+    private final String name;
+    @Getter
+    private final String topLevelName;
+    @Getter
+    private final String path;
+    @Getter
+    private final String query;
+    @Getter
+    private final String fragment;
+    @Getter
+    private final String protocol;
+
+    public Domain(String fullDomain) {
+        // Remove protocol
+        String domainWithPath = fullDomain.contains("://") ? fullDomain.split("://", 2)[1] : fullDomain;
+        this.protocol = fullDomain.contains("://") ? fullDomain.split("://", 2)[0] : "";
+
+        // Cut path
+        String[] domainPartsAndPath = domainWithPath.split("/", 2);
+        String host = domainPartsAndPath[0];                  // z.B. hello.world.com
+        String fullPath = domainPartsAndPath.length > 1 ? "/" + domainPartsAndPath[1] : "";
+
+        // Split domain in labels
+        List<String> labels = Arrays.asList(host.split("\\."));
+        if (labels.size() < 2) throw new IllegalArgumentException("Invalid domain: " + host);
+
+        this.topLevelName = labels.get(labels.size() - 1);
+        this.name = labels.get(labels.size() - 2);
+        this.subname = labels.size() > 2 ? String.join(".", labels.subList(0, labels.size() - 2)) : "";
+
+        if (fullPath.contains("#")) {
+            this.fragment = "#" + Arrays.stream(fullPath.split("#")).toList().getLast();
+            fullPath = fullPath.substring(0, fullPath.length() - ("#" + fragment).length());
+        } else this.fragment = "";
+
+        // Split path and query
+        if (fullPath.contains("?")) {
+            String[] parts = fullPath.split("\\?", 2);
+            this.path = parts[0];
+            this.query = parts[1];
+        } else {
+            this.path = fullPath;
+            this.query = "";
+        }
+    }
+
+    public String getDestination() {
+        return "404";
+    }
+
+}

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/DomainTest.java

@@ -0,0 +1,9 @@
+package github.openautonomousconnection.protocol.versions.v1_0_0.beta;
+
+public class DomainTest {
+
+    public static void main(String[] args) {
+        new Domain("hello.world.com/content/t/lookup.html?what=cooler+test#searchBox");
+    }
+
+}

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicConverter.java

@@ -0,0 +1,15 @@
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
+
+import github.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain;
+
+public class ClassicConverter {
+
+    public static Domain classicDomainToNewDomain(Classic_Domain classicDomain) {
+        return new Domain(classicDomain.name + "." + classicDomain.topLevelDomain + (classicDomain.path.startsWith("/") ? classicDomain.path : "/" + classicDomain.path));
+    }
+
+    public static Classic_Domain newDomainToClassicDomain(Domain newDomain) {
+        return new Classic_Domain(newDomain.getName(), newDomain.getTopLevelName(), newDomain.getDestination(), newDomain.getPath());
+    }
+
+}

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerClient.java

@@ -0,0 +1,9 @@
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
+
+import github.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket;
+
+public abstract class ClassicHandlerClient {
+
+    public abstract void unsupportedClassicPacket(String classicPacketClassName, Object[] content);
+
+}

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerServer.java

@@ -1,13 +1,11 @@
-package github.openautonomousconnection.protocol.handle;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
-import github.openautonomousconnection.protocol.classic.Classic_Domain;
-import github.openautonomousconnection.protocol.classic.Classic_RequestDomain;
 import me.finn.unlegitlibrary.network.system.server.ConnectionHandler;
 
 import java.sql.SQLException;
 
 public abstract class ClassicHandlerServer {
-    public abstract void handleMessage(ConnectionHandler connectionHandler, String message);
+    public abstract void handleMessage(ConnectionHandler connectionHandler, String message, Classic_ProtocolVersion protocolVersion);
     public abstract Classic_Domain getDomain(Classic_RequestDomain requestDomain) throws SQLException;
     public abstract Classic_Domain ping(Classic_RequestDomain requestDomain) throws SQLException;
 }

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_Domain.java

@@ -0,0 +1,40 @@
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
+
+import github.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain;
+import github.openautonomousconnection.protocol.versions.v1_0_0.beta.DomainTest;
+import lombok.Getter;
+import me.finn.unlegitlibrary.string.StringUtils;
+
+import java.io.Serializable;
+
+public class Classic_Domain implements Serializable {
+    public final String name;
+    public final String topLevelDomain;
+    private final String destination;
+    public final String path;
+    @Getter private final Domain domain;
+
+    public Classic_Domain(String name, String topLevelDomain, String destination, String path) {
+        this.domain = new Domain(name + "." + topLevelDomain + "/" + (path.startsWith("/") ? path : "/" + path);
+        this.name = domain.getName();
+        this.topLevelDomain = domain.getTopLevelName();
+        this.destination = domain.getDestination();
+        this.path = domain.getPath();
+    }
+
+    @Override
+    protected final Object clone() throws CloneNotSupportedException {
+        return new Classic_Domain(name, topLevelDomain, destination, path);
+    }
+
+    @Override
+    public final boolean equals(Object obj) {
+        if (!(obj instanceof Classic_Domain other)) return false;
+        return other.name.equalsIgnoreCase(name) && other.topLevelDomain.equalsIgnoreCase(topLevelDomain);
+    }
+
+    @Override
+    public final int hashCode() {
+        return super.hashCode();
+    }
+}

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_DomainPacketReceivedEvent.java

@@ -1,6 +1,5 @@
-package github.openautonomousconnection.protocol.classic;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
-import github.openautonomousconnection.protocol.ProtocolVersion;
 import me.finn.unlegitlibrary.event.impl.Event;
 
 public class Classic_DomainPacketReceivedEvent extends Event {

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_DomainUtils.java

@@ -1,4 +1,4 @@
-package github.openautonomousconnection.protocol.classic;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
 import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider;
 

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_LocalDomain.java

@@ -1,4 +1,4 @@
-package github.openautonomousconnection.protocol.classic;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
 public class Classic_LocalDomain extends Classic_Domain {
     public Classic_LocalDomain(String name, String endName, String path) {

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_PingPacketReceivedEvent.java

@@ -1,4 +1,4 @@
-package github.openautonomousconnection.protocol.classic;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
 import me.finn.unlegitlibrary.event.impl.Event;
 

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_ProtocolVersion.java

@@ -1,4 +1,4 @@
-package github.openautonomousconnection.protocol.classic;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
 import java.io.Serializable;
 

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_RequestDomain.java

@@ -1,4 +1,4 @@
-package github.openautonomousconnection.protocol.classic;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
 import java.io.Serializable;
 

src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_SiteType.java

@@ -1,4 +1,4 @@
-package github.openautonomousconnection.protocol.classic;
+package github.openautonomousconnection.protocol.versions.v1_0_0.classic;
 
 import java.io.Serializable;