diff --git a/pom.xml b/pom.xml index f7fb91f..2e233c8 100644 --- a/pom.xml +++ b/pom.xml @@ -6,7 +6,7 @@ github.openautonomousconnection protocol - 1.0.3-SNAPSHOT + 1.0.0-BETA.1 Open Autonomous Connection https://open-autonomous-connection.org/ @@ -87,7 +87,7 @@ me.finn.unlegitlibrary unlegitlibrary - 1.5.15 + 1.6.2 org.projectlombok diff --git a/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java b/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java index b0b8cde..a6168a3 100644 --- a/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java +++ b/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.packets.v1_0_0.classic.Classic_PingPacket; -import github.openautonomousconnection.protocol.side.ProtocolClient; -import github.openautonomousconnection.protocol.side.ProtocolServer; +import github.openautonomousconnection.protocol.side.client.ProtocolClient; +import github.openautonomousconnection.protocol.side.server.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()); - protocolSettings.packetHandler.registerPacket(new Classic_MessagePacket()); - protocolSettings.packetHandler.registerPacket(new Classic_PingPacket()); + Classic_DomainPacket cDomainPacket = new Classic_DomainPacket(); + Classic_DomainPacket cMessagePacket = new Classic_DomainPacket(); + 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); } } diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java b/src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java deleted file mode 100644 index 9ceb4c5..0000000 --- a/src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java +++ /dev/null @@ -1,4 +0,0 @@ -package github.openautonomousconnection.protocol.classic; - -public class ClassicConverter { -} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java deleted file mode 100644 index 55eb160..0000000 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java +++ /dev/null @@ -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(); - } -} diff --git a/src/main/java/github/openautonomousconnection/protocol/listeners/ClientListener.java b/src/main/java/github/openautonomousconnection/protocol/listeners/ClientListener.java new file mode 100644 index 0000000..f56aa1b --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/listeners/ServerListener.java b/src/main/java/github/openautonomousconnection/protocol/listeners/ServerListener.java new file mode 100644 index 0000000..d32e8b2 --- /dev/null +++ b/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); + } + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java index 926ae80..5185b7c 100644 --- a/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java +++ b/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.ProtocolVersion; +import github.openautonomousconnection.protocol.versions.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; } } diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/AuthPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/AuthPacket.java new file mode 100644 index 0000000..5326d7b --- /dev/null +++ b/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()); + } + } + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java new file mode 100644 index 0000000..80acf28 --- /dev/null +++ b/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 unsupportedClassicPacket; + private Object[] content; + + public UnsupportedClassicPacket(Class 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); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_DomainPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_DomainPacket.java index ec1f8d3..dfda931 100644 --- a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_DomainPacket.java +++ b/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.classic.Classic_Domain; -import github.openautonomousconnection.protocol.classic.Classic_DomainPacketReceivedEvent; -import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion; -import github.openautonomousconnection.protocol.classic.Classic_RequestDomain; +import github.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket; +import github.openautonomousconnection.protocol.versions.ProtocolVersion; +import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_Domain; +import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_DomainPacketReceivedEvent; +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})); } } diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java index db0b6b8..57560ed 100644 --- a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java +++ b/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.classic.Classic_ProtocolVersion; +import github.openautonomousconnection.protocol.versions.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); } } diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_PingPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_PingPacket.java index 657937b..dfd7361 100644 --- a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_PingPacket.java +++ b/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.classic.Classic_Domain; -import github.openautonomousconnection.protocol.classic.Classic_PingPacketReceivedEvent; -import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion; -import github.openautonomousconnection.protocol.classic.Classic_RequestDomain; +import github.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket; +import github.openautonomousconnection.protocol.versions.ProtocolVersion; +import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_Domain; +import github.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_PingPacketReceivedEvent; +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})); } } diff --git a/src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java b/src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java deleted file mode 100644 index 09ff1e1..0000000 --- a/src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java +++ /dev/null @@ -1,4 +0,0 @@ -package github.openautonomousconnection.protocol.side; - -public class ProtocolClient { -} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java b/src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java deleted file mode 100644 index 91317c7..0000000 --- a/src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java +++ /dev/null @@ -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(); - } -} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/client/ProtocolClient.java b/src/main/java/github/openautonomousconnection/protocol/side/client/ProtocolClient.java new file mode 100644 index 0000000..62adabe --- /dev/null +++ b/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(); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/client/events/ConnectedToProtocolServer.java b/src/main/java/github/openautonomousconnection/protocol/side/client/events/ConnectedToProtocolServer.java new file mode 100644 index 0000000..0ca86e5 --- /dev/null +++ b/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 { +} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/server/ConnectedProtocolClient.java b/src/main/java/github/openautonomousconnection/protocol/side/server/ConnectedProtocolClient.java new file mode 100644 index 0000000..8ff0648 --- /dev/null +++ b/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); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/server/ProtocolServer.java b/src/main/java/github/openautonomousconnection/protocol/side/server/ProtocolServer.java new file mode 100644 index 0000000..8b6fd8b --- /dev/null +++ b/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 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(); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/server/events/ProtocolClientConnected.java b/src/main/java/github/openautonomousconnection/protocol/side/server/events/ProtocolClientConnected.java new file mode 100644 index 0000000..898b6ae --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java b/src/main/java/github/openautonomousconnection/protocol/versions/ProtocolVersion.java similarity index 87% rename from src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java rename to src/main/java/github/openautonomousconnection/protocol/versions/ProtocolVersion.java index 2ded151..bc1cbe8 100644 --- a/src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java +++ b/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 diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/Domain.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/Domain.java new file mode 100644 index 0000000..2f664d4 --- /dev/null +++ b/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 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"; + } + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/DomainTest.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/DomainTest.java new file mode 100644 index 0000000..ff884a2 --- /dev/null +++ b/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"); + } + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicConverter.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicConverter.java new file mode 100644 index 0000000..120986c --- /dev/null +++ b/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()); + } + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerClient.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerClient.java new file mode 100644 index 0000000..daba836 --- /dev/null +++ b/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); + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandlerServer.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerServer.java similarity index 63% rename from src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandlerServer.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerServer.java index 101de7f..777b9a6 100644 --- a/src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandlerServer.java +++ b/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; } diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_Domain.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_Domain.java new file mode 100644 index 0000000..06aeb18 --- /dev/null +++ b/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(); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainPacketReceivedEvent.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_DomainPacketReceivedEvent.java similarity index 89% rename from src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainPacketReceivedEvent.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_DomainPacketReceivedEvent.java index dbb34d7..7dc6e77 100644 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainPacketReceivedEvent.java +++ b/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 { diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_DomainUtils.java similarity index 97% rename from src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_DomainUtils.java index 209e4fc..d3f0399 100644 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java +++ b/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; diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_LocalDomain.java similarity index 71% rename from src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_LocalDomain.java index 9d635d1..727157a 100644 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java +++ b/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) { diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_PingPacketReceivedEvent.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_PingPacketReceivedEvent.java similarity index 93% rename from src/main/java/github/openautonomousconnection/protocol/classic/Classic_PingPacketReceivedEvent.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_PingPacketReceivedEvent.java index 3200b2c..26f13bf 100644 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_PingPacketReceivedEvent.java +++ b/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; diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_ProtocolVersion.java similarity index 76% rename from src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_ProtocolVersion.java index 82b491f..ac07baa 100644 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java +++ b/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; diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_RequestDomain.java similarity index 77% rename from src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_RequestDomain.java index 3b68223..8cd2798 100644 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java +++ b/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; diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_SiteType.java similarity index 80% rename from src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java rename to src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/Classic_SiteType.java index 7cd9fcc..64c2e51 100644 --- a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java +++ b/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;